rr 1.1.1 → 1.1.2.rc1

data/spec/suites/rspec_2/unit/expectations/times_called_expectation/integer_matcher_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
+
+module RR
+  module Expectations
+    describe TimesCalledExpectation do
+      context "when using an IntegerMatcher" do
+        include_examples "RR::Expectations::TimesCalledExpectation"
+
+        before do
+          stub(subject).foobar.times(2)
+        end
+
+        describe "verify" do
+          it "passes after attempt! called 2 times" do
+            subject.foobar
+            subject.foobar
+            RR.verify
+          end
+
+          it "fails after attempt! called 1 time" do
+            subject.foobar
+            expect { RR.verify }.to raise_error(
+              RR::Errors::TimesCalledError,
+              "foobar()\nCalled 1 time.\nExpected 2 times."
+            )
+          end
+
+          it "can't be called when attempt! is called 3 times" do
+            subject.foobar
+            subject.foobar
+            expect {
+              subject.foobar
+            }.to raise_error(RR::Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 2 times.")
+            expect {
+              RR.verify
+            }.to raise_error(RR::Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 2 times.")
+          end
+
+          it "has a backtrace to where the TimesCalledExpectation was instantiated on failure" do
+            error = nil
+            begin
+              RR.verify
+            rescue RR::Errors::TimesCalledError => e
+              error = e
+            end
+            expect(e.backtrace.join("\n")).to include(__FILE__)
+          end
+
+          it "has an error message that includes the number of times called and expected number of times" do
+            expect {
+              RR.verify
+            }.to raise_error(RR::Errors::TimesCalledError, "foobar()\nCalled 0 times.\nExpected 2 times.")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/expectations/times_called_expectation/proc_matcher_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
+
+module RR
+  module Expectations
+    describe TimesCalledExpectation do
+      context "when using a ProcMatcher" do
+        include_examples "RR::Expectations::TimesCalledExpectation"
+
+        before do
+          stub(subject).foobar.times(lambda {|value| value == 2})
+        end
+
+        describe "#verify" do
+          it "passes after attempt! called 2 times" do
+            subject.foobar
+            subject.foobar
+            RR.verify
+          end
+
+          it "fails after attempt! called 1 time" do
+            subject.foobar
+            expect { RR.verify }.to raise_error(RR::Errors::TimesCalledError)
+          end
+
+          it "fails after attempt! called 3 times" do
+            subject.foobar
+            subject.foobar
+            subject.foobar
+            expect { RR.verify }.to raise_error(RR::Errors::TimesCalledError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/expectations/times_called_expectation/range_matcher_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
+
+module RR
+  module Expectations
+    describe TimesCalledExpectation do
+      context "when using a RangeMatcher" do
+        include_examples "RR::Expectations::TimesCalledExpectation"
+
+        before do
+          stub(subject).foobar.times(1..2)
+        end
+
+        describe "#verify" do
+          it "passes after attempt! called 1 time" do
+            subject.foobar
+            RR.verify
+          end
+
+          it "passes after attempt! called 2 times" do
+            subject.foobar
+            subject.foobar
+            RR.verify
+          end
+
+          it "can't be called when attempt! is called 3 times" do
+            subject.foobar
+            subject.foobar
+            expect {
+              subject.foobar
+            }.to raise_error(RR::Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 1..2 times.")
+            expect {
+              RR.verify
+            }.to raise_error(RR::Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 1..2 times.")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/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
+
+        expect(hash[array_1]).to_not eq hash[array_2]
+      end
+
+      it "stores the passed in object" do
+        hash = HashWithObjectIdKey.new
+        obj = Object.new
+        hash[obj] = 1
+        expect(hash.instance_eval {@keys}).to eq({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
+
+        expect(keys.sort).to eq ['one', 'two']
+        expect(values.sort).to eq [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)
+        expect(@hash[@key]).to be_nil
+      end
+
+      it "removes the object from the keys hash" do
+        @hash.delete(@key)
+        expect(@hash.instance_eval { @keys }).to eq({})
+      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
+        expect(@hash.keys).to eq [@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
+        expect(@hash.include?(@key)).to be_true
+      end
+
+      it "returns false when the key is not in the Hash" do
+        expect(@hash.include?(Object.new)).to be_false
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/injections/double_injection/double_injection_spec.rb

@@ -0,0 +1,545 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
+
+module RR
+  module Injections
+    describe DoubleInjection do
+      attr_reader :method_name, :double_injection
+
+      macro("sets up subject and method_name") do
+        it "sets up subject and method_name" do
+          expect(double_injection.subject).to equal subject
+          expect(double_injection.method_name).to eq method_name.to_sym
+        end
+      end
+
+      subject { Object.new }
+
+      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
+
+            expect(subject).to respond_to(:foobar)
+            expect(!!subject.methods.detect {|method| method.to_sym == :foobar}).to be_true
+            stub(subject).foobar {:new_foobar}
+          end
+
+          describe "being bound" do
+            it "sets __rr__original_{method_name} to the original method" do
+              expect(subject.__rr__original_foobar).to eq :original_foobar
+            end
+
+            describe "being called" do
+              it "returns the return value of the block" do
+                expect(subject.foobar).to eq :new_foobar
+              end
+
+              it "does not call the original method" do
+                subject.foobar
+                expect(subject.original_foobar_called).to be_nil
+              end
+            end
+
+            describe "being reset" do
+              before do
+                RR::Space.reset_double(subject, :foobar)
+              end
+
+              it "rebinds the original method" do
+                expect(subject.foobar).to eq :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
+              expect(subject.foobar).to eq :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
+            expect(subject.foobar).to eq 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
+
+                expect(subject).to respond_to(:foobar)
+                expect(!!subject.methods.detect {|method| method.to_sym == :foobar}).to be_true
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              it "aliases the original method to __rr__original_{method_name}" do
+                expect(subject.__rr__original_foobar).to eq :original_foobar
+              end
+
+              it "replaces the original method with the new method" do
+                expect(subject.foobar).to eq :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}
+                  expect(subject.foobar).to eq :new_foobar
+                  expect(original_return_value).to eq :original_foobar
+                end
+              end
+
+              describe "being reset" do
+                before do
+                  RR::Space.reset_double(subject, :foobar)
+                end
+
+                it "rebinds the original method" do
+                  expect(subject.foobar).to eq :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
+
+                  expect(subject).to 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
+                      expect((!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar})).to be_true
+                      expect(subject.__rr__original_foobar).to eq :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}
+                      expect(subject.foobar).to eq :new_foobar
+                      expect(original_return_value).to eq :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    before do
+                      RR::Space.reset_double(subject, :foobar)
+                    end
+
+                    it "rebinds the original method" do
+                      expect(subject.foobar).to eq :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
+                        expect((!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar})).to be_true
+                        expect(subject.__rr__original_foobar).to eq :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}
+                        expect(subject.foobar).to eq :new_foobar
+                        expect(original_return_value).to eq :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
+                          expect(subject.foobar).to eq :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}
+                        expect(subject.foobar).to eq :new_foobar
+                        expect(original_return_value).to eq :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        expect(subject.foobar).to eq :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
+
+                  expect(subject).to 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
+                      expect((!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar})).to be_true
+                      expect(subject.__rr__original_foobar).to eq :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}
+                      expect(subject.foobar).to eq :new_foobar
+                      expect(original_return_value).to eq :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    before do
+                      RR::Space.reset_double(subject, :foobar)
+                    end
+
+                    it "rebinds the original method" do
+                      expect(subject.foobar).to eq :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
+                        expect((!!subject.methods.detect {|method| method.to_sym == :__rr__original_foobar})).to be_true
+                        expect(subject.__rr__original_foobar).to eq :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}
+                        expect(subject.foobar).to eq :new_foobar
+                        expect(original_return_value).to eq :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
+                          expect(subject.foobar).to eq :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}
+                        expect(subject.foobar).to eq :new_foobar
+                        expect(original_return_value).to eq :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        expect(subject.foobar).to eq :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
+                expect(subject).to respond_to(:foobar)
+                expect((!!subject.methods.detect {|method| method.to_sym == :foobar})).to 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}
+                  expect(subject.foobar).to eq :new_foobar
+                  expect(original_return_value).to eq :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
+                expect(subject).to respond_to(:foobar)
+                expect((!!subject.methods.detect {|method| method.to_sym == :foobar})).to be_true
+              end
+
+              describe "being called" do
+                it "raises a NoMethodError" do
+                  expect {
+                    subject.foobar
+                  }.to 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