rr 0.3.11 → 0.4.0

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

@@ -0,0 +1,81 @@
+require "spec/spec_helper"
+
+module RR
+  module Expectations
+    describe TimesCalledExpectation, " with RangeMatcher" do
+      it_should_behave_like "RR::Expectations::TimesCalledExpectation"
+      attr_reader :matcher
+
+      before do
+        @matcher = TimesCalledMatchers::RangeMatcher.new(1..2)
+        @expectation = TimesCalledExpectation.new(scenario, matcher)
+      end
+
+      describe "#verify" do
+        it "returns true when times called falls within a range" do
+          expectation.verify.should == false
+          expectation.attempt!
+          expectation.verify.should == true
+          expectation.attempt!
+          expectation.verify.should == true
+        end
+      end
+
+      describe "#verify! when passed a Range (1..2)" do
+        it "passes after attempt! called 1 time" do
+          expectation.attempt!
+          expectation.verify!
+        end
+
+        it "passes after attempt! called 2 times" do
+          expectation.attempt!
+          expectation.attempt!
+          expectation.verify!
+        end
+
+        it "can't be called when attempt! is called 3 times" do
+          expectation.attempt!
+          expectation.attempt!
+          proc do
+            expectation.attempt!
+          end.should raise_error(Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 1..2 times.")
+        end
+      end
+
+      describe "#attempt? with RangeMatcher" do
+        it "returns true when attempted less than low end of range" do
+          expectation.should be_attempt
+        end
+
+        it "returns false when attempted in range" do
+          expectation.attempt!
+          expectation.should be_attempt
+          expectation.attempt!
+          expectation.should be_attempt
+        end
+
+        it "raises error before attempted more than expected times" do
+          2.times {expectation.attempt!}
+          proc {expectation.attempt!}.should raise_error(
+          Errors::TimesCalledError
+          )
+        end
+      end
+
+      describe "#attempt! for a range expectation" do
+        it "raises error when attempt! called more than range permits" do
+          expectation.attempt!
+          expectation.attempt!
+          raises_expectation_error {expectation.attempt!}
+        end
+      end
+
+      describe "#terminal? with RangeMatcher" do
+        it "returns true" do
+          expectation.should be_terminal
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,40 @@
+require "spec/spec_helper"
+
+module RR
+  module Expectations
+    describe TimesCalledExpectation, " with failure" do
+      it_should_behave_like "RR::Expectations::TimesCalledExpectation"
+      attr_reader :times, :matcher
+
+      before do
+        @times = 0
+        @matcher = TimesCalledMatchers::IntegerMatcher.new(times)
+        @expectation = TimesCalledExpectation.new(scenario, matcher)
+      end
+      
+      describe "#attempt!" do
+        it "raises error that includes the scenario" do
+          proc do
+            expectation.attempt!
+          end.should raise_error(
+          Errors::TimesCalledError,
+          "#{scenario.formatted_name}\n#{matcher.error_message(1)}"
+          )
+        end
+      end
+
+      describe "#verify!" do
+        it "raises error with passed in message prepended" do
+          expectation.instance_variable_set(:@times_called, 1)
+          proc do
+            expectation.verify!
+          end.should raise_error(
+          Errors::TimesCalledError,
+          "#{scenario.formatted_name}\n#{matcher.error_message(1)}"
+          )
+        end
+      end
+    end
+
+  end
+end

data/spec/rr/rspec/rspec_adapter_spec.rb

@@ -0,0 +1,65 @@
+require "spec/spec_helper"
+
+module RR
+  module Adapters
+    describe Rspec do
+      describe "#setup_mocks_for_rspec" do
+        before do
+          @fixture = Object.new
+          @fixture.extend Rspec
+
+          @subject = Object.new
+          @method_name = :foobar
+        end
+
+        it "resets the double_insertions" do
+          RR::Space.double_insertion(@subject, @method_name)
+          RR::Space.double_insertions.should_not be_empty
+
+          @fixture.setup_mocks_for_rspec
+          RR::Space.double_insertions.should be_empty
+        end
+      end
+
+      describe "#verify_mocks_for_rspec" do
+        before do
+          @fixture = Object.new
+          @fixture.extend Rspec
+
+          @subject = Object.new
+          @method_name = :foobar
+        end
+
+        it "verifies the double_insertions" do
+          double_insertion = RR::Space.double_insertion(@subject, @method_name)
+          scenario = RR::Space.scenario(double_insertion)
+
+          scenario.once
+
+          proc do
+            @fixture.verify_mocks_for_rspec
+          end.should raise_error(::RR::Errors::TimesCalledError)
+          RR::Space.double_insertions.should be_empty
+        end
+      end
+
+      describe "#teardown_mocks_for_rspec" do
+        before do
+          @fixture = Object.new
+          @fixture.extend Rspec
+
+          @subject = Object.new
+          @method_name = :foobar
+        end
+
+        it "resets the double_insertions" do
+          RR::Space.double_insertion(@subject, @method_name)
+          RR::Space.double_insertions.should_not be_empty
+
+          @fixture.teardown_mocks_for_rspec
+          RR::Space.double_insertions.should be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rr/rspec/rspec_backtrace_tweaking_spec.rb

@@ -0,0 +1,52 @@
+require "spec/spec_helper"
+
+module RR
+  module Adapters
+    describe Rspec do
+      describe "#trim_backtrace" do
+        it "does not set trim_backtrace" do
+          RR::Space.trim_backtrace.should == false
+        end
+      end
+
+      describe ".included" do
+        it "does not add backtrace identifier twice" do
+          length = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.length
+          class << Object.new
+            include ::RR::Adapters::Rspec
+          end
+          ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.length.should == length
+        end
+      end
+
+      describe " backtrace tweaking" do
+        attr_reader :original_rspec_options, :output
+        before do
+          @original_rspec_options = $rspec_options
+          @output = StringIO.new("")
+          $rspec_options = ::Spec::Runner::Options.new(output, StringIO.new)
+        end
+
+        after do
+          $rspec_options = original_rspec_options
+        end
+
+        it "hides rr library from the backtrace by default" do
+          subject = @subject
+          Class.new(::Spec::Example::ExampleGroup) do
+            describe "Example"
+
+            it("hides RR framework in backtrace") do
+              mock(subject).foobar()
+              RR::Space::instance.verify_double(subject, :foobar)
+            end
+          end
+
+          $rspec_options.run_examples
+
+          output.string.should_not include("lib/rr")
+        end
+      end
+    end
+  end
+end

data/spec/rr/rspec/rspec_usage_spec.rb

@@ -0,0 +1,67 @@
+require "spec/spec_helper"
+
+describe RR do
+  describe "#mock" do
+    before do
+      @subject = Object.new
+    end
+
+    it "creates a mock DoubleInsertion Double" do
+      mock(@subject).foobar(1, 2) {:baz}
+      @subject.foobar(1, 2).should == :baz
+    end
+  end
+
+  describe "#stub" do
+    before do
+      @subject = Object.new
+    end
+
+    it "creates a stub DoubleInsertion Double" do
+      stub(@subject).foobar {:baz}
+      @subject.foobar("any", "thing").should == :baz
+    end
+  end
+
+  describe "#mock and #proxy" do
+    before do
+      @subject = Object.new
+      def @subject.foobar
+        :baz
+      end
+    end
+
+    it "creates a proxy DoubleInsertion Double" do
+      mock.proxy(@subject).foobar
+      @subject.foobar.should == :baz
+    end
+  end
+
+  describe "#stub and #proxy" do
+    before do
+      @subject = Object.new
+      def @subject.foobar
+        :baz
+      end
+    end
+
+    it "creates a proxy DoubleInsertion Double" do
+      stub.proxy(@subject).foobar
+      @subject.foobar.should == :baz
+    end
+  end
+
+  describe "#stub and #proxy" do
+    before do
+      @subject = Object.new
+      def @subject.foobar
+        :baz
+      end
+    end
+
+    it "creates a proxy DoubleInsertion Double" do
+      stub.proxy(@subject).foobar
+      @subject.foobar.should == :baz
+    end
+  end
+end

data/spec/rr/space/hash_with_object_id_key_spec.rb

@@ -0,0 +1,88 @@
+require "spec/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.should include(@key)
+      end
+
+      it "returns false when the key is not in the Hash" do
+        @hash.should_not include(Object.new)
+      end
+    end
+  end
+end

data/spec/rr/space/space_create_spec.rb

@@ -0,0 +1,278 @@
+require "spec/spec_helper"
+
+module RR
+  describe Space, "#scenario_method_proxy", :shared => true do
+    it_should_behave_like "RR::Space"
+
+    before do
+      @space = Space.new
+      @object = Object.new
+    end
+
+    it "creates a DoubleMethodProxy" do
+      proxy = @space.scenario_method_proxy(@creator, @object)
+      proxy.should be_instance_of(DoubleMethodProxy)
+    end
+
+    it "sets space to self" do
+      proxy = @space.scenario_method_proxy(@creator, @object)
+      class << proxy
+        attr_reader :space
+      end
+      proxy.space.should === @space
+    end
+
+    it "sets creator to passed in creator" do
+      proxy = @space.scenario_method_proxy(@creator, @object)
+      class << proxy
+        attr_reader :creator
+      end
+      proxy.creator.should === @creator
+    end
+
+    it "raises error if passed a method name and a block" do
+      proc do
+        @space.scenario_method_proxy(@creator, @object, :foobar) {}
+      end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+    end
+  end
+
+  describe Space, "#scenario_method_proxy with a Mock strategy" do
+    it_should_behave_like "RR::Space#scenario_method_proxy"
+
+    before do
+      @creator = @space.scenario_creator
+      @creator.mock
+    end
+
+    it "creates a mock Double for method when passed a second argument" do
+      @space.scenario_method_proxy(@creator, @object, :foobar).with(1) {:baz}
+      @object.foobar(1).should == :baz
+      proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+    end
+
+    it "uses block definition when passed a block" do
+      @space.scenario_method_proxy(@creator, @object) do |c|
+        c.foobar(1) {:baz}
+      end
+      @object.foobar(1).should == :baz
+      proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+    end
+  end
+
+  describe Space, "#scenario_method_proxy with a Stub strategy" do
+    it_should_behave_like "RR::Space#scenario_method_proxy"
+
+    before do
+      @creator = @space.scenario_creator
+      @creator.stub
+    end
+
+    it "creates a stub Double for method when passed a second argument" do
+      @space.scenario_method_proxy(@creator, @object, :foobar).with(1) {:baz}
+      @object.foobar(1).should == :baz
+      @object.foobar(1).should == :baz
+    end
+
+    it "uses block definition when passed a block" do
+      @space.scenario_method_proxy(@creator, @object) do |c|
+        c.foobar(1) {:return_value}
+        c.foobar.with_any_args {:default}
+        c.baz(1) {:baz_value}
+      end
+      @object.foobar(1).should == :return_value
+      @object.foobar.should == :default
+      proc {@object.baz.should == :return_value}.should raise_error
+    end
+  end
+
+  describe Space, "#scenario_method_proxy with a Mock Proxy strategy" do
+    it_should_behave_like "RR::Space#scenario_method_proxy"
+
+    before do
+      @creator = @space.scenario_creator
+      @creator.mock.proxy
+      def @object.foobar(*args)
+        :original_foobar
+      end
+    end
+
+    it "creates a mock proxy Double for method when passed a second argument" do
+      @space.scenario_method_proxy(@creator, @object, :foobar).with(1)
+      @object.foobar(1).should == :original_foobar
+      proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+    end
+
+    it "uses block definition when passed a block" do
+      @space.scenario_method_proxy(@creator, @object) do |c|
+        c.foobar(1)
+      end
+      @object.foobar(1).should == :original_foobar
+      proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+    end
+  end
+
+  describe Space, "#scenario_method_proxy with a Stub proxy strategy" do
+    it_should_behave_like "RR::Space#scenario_method_proxy"
+
+    before do
+      @creator = @space.scenario_creator
+      @creator.stub.proxy
+      def @object.foobar(*args)
+        :original_foobar
+      end
+    end
+
+    it "creates a stub proxy Double for method when passed a second argument" do
+      @space.scenario_method_proxy(@creator, @object, :foobar)
+      @object.foobar(1).should == :original_foobar
+      @object.foobar(1).should == :original_foobar
+    end
+
+    it "uses block definition when passed a block" do
+      @space.scenario_method_proxy(@creator, @object) do |c|
+        c.foobar(1)
+      end
+      @object.foobar(1).should == :original_foobar
+      @object.foobar(1).should == :original_foobar
+    end
+  end
+
+  describe Space, "#scenario_method_proxy with a Do Not Allow strategy" do
+    it_should_behave_like "RR::Space#scenario_method_proxy"
+
+    before do
+      @creator = @space.scenario_creator
+      @creator.dont_allow
+    end
+
+    it "creates a do not allow Double for method when passed a second argument" do
+      @space.scenario_method_proxy(@creator, @object, :foobar).with(1)
+      proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+    end
+
+    it "uses block definition when passed a block" do
+      @space.scenario_method_proxy(@creator, @object) do |c|
+        c.foobar(1)
+      end
+      proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+    end
+  end
+
+  describe Space, "#scenario_creator" do
+    it_should_behave_like "RR::Space"
+
+    before do
+      @space = Space.new
+      @object = Object.new
+      @creator = @space.scenario_creator
+    end
+
+    it "sets the space" do
+      @creator.space.should === @space
+    end
+
+    it "creates a DoubleCreator" do
+      @creator.should be_instance_of(DoubleCreator)
+    end
+  end
+
+  describe Space, "#scenario" do
+    it_should_behave_like "RR::Space"
+
+    before do
+      @space = Space.new
+      @object = Object.new
+      @method_name = :foobar
+    end
+
+    it "creates a Double and registers it to the double_insertion" do
+      double_insertion = @space.double_insertion(@object, @method_name)
+      def double_insertion.scenarios
+        @scenarios
+      end
+
+      scenario = @space.scenario(double_insertion)
+      double_insertion.scenarios.should include(scenario)
+    end
+  end
+
+  describe Space, "#double_insertion" do
+    it_should_behave_like "RR::Space"
+
+    before do
+      @space = Space.new
+    end
+
+    it "creates a new double_insertion when existing object == but not === with the same method name" do
+      object1 = []
+      object2 = []
+      (object1 === object2).should be_true
+      object1.__id__.should_not == object2.__id__
+
+      double1 = @space.double_insertion(object1, :foobar)
+      double2 = @space.double_insertion(object2, :foobar)
+
+      double1.should_not == double2
+    end
+  end
+
+  describe Space, "#double_insertion when double_insertion does not exist" do
+    it_should_behave_like "RR::Space"
+
+    before do
+      @space = Space.new
+      @object = Object.new
+      def @object.foobar(*args)
+        :original_foobar
+      end
+      @method_name = :foobar
+    end
+
+    it "returns double_insertion and adds double_insertion to double_insertion list when method_name is a symbol" do
+      double_insertion = @space.double_insertion(@object, @method_name)
+      @space.double_insertion(@object, @method_name).should === double_insertion
+      double_insertion.space.should === @space
+      double_insertion.object.should === @object
+      double_insertion.method_name.should === @method_name
+    end
+
+    it "returns double_insertion and adds double_insertion to double_insertion list when method_name is a string" do
+      double_insertion = @space.double_insertion(@object, 'foobar')
+      @space.double_insertion(@object, @method_name).should === double_insertion
+      double_insertion.space.should === @space
+      double_insertion.object.should === @object
+      double_insertion.method_name.should === @method_name
+    end
+
+    it "overrides the method when passing a block" do
+      double_insertion = @space.double_insertion(@object, @method_name)
+      @object.methods.should include("__rr__#{@method_name}")
+    end
+  end
+
+  describe Space, "#double_insertion when double_insertion exists" do
+    it_should_behave_like "RR::Space"
+
+    before do
+      @space = Space.new
+      @object = Object.new
+      def @object.foobar(*args)
+        :original_foobar
+      end
+      @method_name = :foobar
+    end
+
+    it "returns the existing double_insertion" do
+      original_foobar_method = @object.method(:foobar)
+      double_insertion = @space.double_insertion(@object, 'foobar')
+
+      double_insertion.object_has_original_method?.should be_true
+
+      @space.double_insertion(@object, 'foobar').should === double_insertion
+
+      double_insertion.reset
+      @object.foobar.should == :original_foobar
+    end
+  end
+end