mcmire-rr 1.0.5.rc1

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 Injections
+    describe DoubleInjection, "#verify" do
+      it_should_behave_like "Swapped Space"
+      attr_reader :subject, :method_name, :double_injection
+      before do
+        @subject = Object.new
+        @method_name = :foobar
+        subject.methods.should_not include(method_name.to_s)
+        @double_injection = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
+      end
+
+      it "verifies each double was met" do
+        double = RR::Double.new(
+          double_injection,
+          RR::DoubleDefinitions::DoubleDefinition.new(RR::DoubleDefinitions::DoubleDefinitionCreate.new)
+        )
+        double_injection.register_double double
+
+        double.definition.with(1).once.returns {nil}
+        lambda {double_injection.verify}.should raise_error(RR::Errors::TimesCalledError)
+        subject.foobar(1)
+        lambda {double_injection.verify}.should_not raise_error
+      end
+    end
+  end
+end

data/spec/rr/errors/rr_error_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Errors
+    describe RRError do
+      describe "#backtrace" do
+        before do
+          @original_trim_backtrace = RR.trim_backtrace
+        end
+        after do
+          RR.trim_backtrace = @original_trim_backtrace
+        end
+
+        it "does not include the rr library files when trim_backtrace is true" do
+          RR.trim_backtrace = true
+
+          error = nil
+          begin
+            obj = Object.new
+            mock(obj).foobar
+            RR.verify_double(obj, :foobar)
+          rescue RRError=> e
+            error = e
+          end
+          backtrace = error.backtrace.join("\n")
+
+          backtrace.should_not include("lib/rr")
+        end
+
+        it "includes the rr library files when trim_backtrace is false" do
+          RR.trim_backtrace = false
+
+          error = nil
+          begin
+            obj = Object.new
+            mock(obj).foobar
+            RR.verify_double(obj, :foobar)
+          rescue RRError=> e
+            error = e
+          end
+          backtrace = error.backtrace.join("\n")
+
+          backtrace.should include("lib/rr")
+        end
+
+        it "returns custom backtrace when backtrace is set" do
+          error = RRError.new
+          custom_backtrace = caller
+          error.backtrace = custom_backtrace
+          error.backtrace.should == custom_backtrace
+        end
+
+        it "returns normal backtrace when backtrace is not set" do
+          error = nil
+          expected_line = __LINE__ + 2
+          begin
+            raise RRError
+          rescue RRError => e
+            error = e
+          end
+          error.backtrace.first.should include(__FILE__)
+          error.backtrace.first.should include(expected_line.to_s)
+        end
+      end
+    end
+  end
+end

data/spec/rr/expectations/any_argument_expectation_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Expectations
+    describe AnyArgumentExpectation do
+      attr_reader :expectation
+      before do
+        @expectation = AnyArgumentExpectation.new
+      end
+
+      describe "#expected_arguments" do
+        it "returns an empty array" do
+          expectation.expected_arguments.should == []
+        end
+      end
+
+      describe "==" do
+        it "returns true when comparing with another AnyArgumentExpectation" do
+          expectation.should == AnyArgumentExpectation.new
+        end
+
+        it "returns false when comparing with ArgumentEqualityExpectation" do
+          expectation.should_not == ArgumentEqualityExpectation.new(1)
+        end
+      end
+
+      describe "#exact_match?" do
+        it "returns false" do
+          expectation.should_not be_exact_match(1, 2, 3)
+          expectation.should_not be_exact_match(1, 2)
+          expectation.should_not be_exact_match(1)
+          expectation.should_not be_exact_match()
+          expectation.should_not be_exact_match("does not match")
+        end
+      end
+
+      describe "#wildcard_match?" do
+        it "returns true" do
+          expectation = AnyArgumentExpectation.new
+          expectation.should be_wildcard_match(1, 2, 3)
+          expectation.should be_wildcard_match("whatever")
+          expectation.should be_wildcard_match("whatever", "else")
+        end
+      end
+    end
+  end
+end

data/spec/rr/expectations/anything_argument_equality_expectation_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Expectations
+    describe ArgumentEqualityExpectation do
+      context "when matching anything" do
+        attr_reader :expectation
+        before do
+          @expectation = ArgumentEqualityExpectation.new(anything)
+        end
+      end
+    end
+  end
+end

data/spec/rr/expectations/argument_equality_expectation_spec.rb

@@ -0,0 +1,135 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Expectations
+    describe ArgumentEqualityExpectation do
+      attr_reader :expectation
+      before do
+        @expectation = ArgumentEqualityExpectation.new(1, 2, 3)
+      end
+
+      describe "#expected_arguments" do
+        it "returns the passed in expected_arguments" do
+          expectation.expected_arguments.should == [1, 2, 3]
+        end
+      end
+
+      describe "==" do
+        it "returns true when passed in expected_arguments are equal" do
+          expectation.should == ArgumentEqualityExpectation.new(1, 2, 3)
+        end
+
+        it "returns false when passed in expected_arguments are not equal" do
+          expectation.should_not == ArgumentEqualityExpectation.new(1, 2)
+          expectation.should_not == ArgumentEqualityExpectation.new(1)
+          expectation.should_not == ArgumentEqualityExpectation.new(:something)
+          expectation.should_not == ArgumentEqualityExpectation.new()
+        end
+      end
+
+      describe "#exact_match?" do
+        context "when all arguments exactly match" do
+          it "returns true" do
+            expectation.should be_exact_match(1, 2, 3)
+          end
+        end
+
+        context "when all arguments do not exactly match" do
+          it "returns false" do
+            expectation.should_not be_exact_match(1, 2)
+            expectation.should_not be_exact_match(1)
+            expectation.should_not be_exact_match()
+            expectation.should_not be_exact_match("does not match")
+          end
+        end
+      end
+
+      describe "#wildcard_match?" do
+        context "when not an exact match" do
+          it "returns false" do
+            expectation = ArgumentEqualityExpectation.new(1)
+            expectation.should_not be_wildcard_match(1, 2, 3)
+            expectation.should_not be_wildcard_match("whatever")
+            expectation.should_not be_wildcard_match("whatever", "else")
+          end
+        end
+
+        context "when an exact match" do
+          it "returns true" do
+            expectation = ArgumentEqualityExpectation.new(1, 2)
+            expectation.should be_wildcard_match(1, 2)
+            expectation.should_not be_wildcard_match(1)
+            expectation.should_not be_wildcard_match("whatever", "else")
+          end
+        end
+
+        context "when not passed correct number of arguments" do
+          it "returns false" do
+            expectation.should_not be_wildcard_match()
+            expectation.should_not be_wildcard_match(Object.new, Object.new)
+          end
+        end
+      end
+
+      describe "Functional spec" do
+        class ArgumentEqualityFunctionalFixture
+          attr_reader :arg1, :arg2
+          def initialize(arg1, arg2)
+            @arg1, @arg2 = arg1, arg2
+          end
+
+          def ==(other)
+            arg1 == (other.arg1) &&
+            arg2 == (other.arg2)
+          end
+
+          def eql?(other)
+            arg1.eql?(other.arg1) &&
+            arg2.eql?(other.arg2)
+          end
+        end
+
+        before(:each) do
+          @predicate1 = 'first' # these should be mocks, waiting on rr bug fix
+          @predicate2 = 'second'
+          @predicate3 = 'third'
+        end
+
+        describe "when mock.proxy ==" do
+          it "does not have infinite recursion" do
+            mock.proxy(@predicate1) == @predicate1
+            mock.proxy(@predicate2) == @predicate2
+            ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2).should == ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2)
+
+            mock.proxy(@predicate1) == @predicate1
+            mock.proxy(@predicate2) == @predicate3
+            ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2).should_not == ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate3)
+          end
+
+          it "matches Hashes properly (using ==)" do
+            mock.proxy(@predicate1) == {:foo => :bar}
+            @predicate1 == {:foo => :bar}
+          end
+        end
+
+        describe "when mock.proxy .eql?" do
+          it "does not have infinite recursion" do
+            mock.proxy(@predicate1).eql? @predicate1
+            mock.proxy(@predicate2).eql? @predicate2
+            ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2).should be_eql(ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2))
+
+            mock.proxy(@predicate1).eql? @predicate1
+            mock.proxy(@predicate2).eql? @predicate3
+            ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2).should_not be_eql(ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate3))
+          end
+
+          it "matches Hashes properly (using ==)" do
+            mock.proxy(@predicate1).eql?({:foo => :bar})
+            @predicate1.eql?({:foo => :bar})
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/rr/expectations/boolean_argument_equality_expectation_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Expectations
+    describe ArgumentEqualityExpectation do
+      context "with a boolean matcher" do
+        attr_reader :expectation
+
+        before do
+          @expectation = ArgumentEqualityExpectation.new(boolean)
+        end
+
+        describe "#wildcard_match?" do
+          before do
+            expectation = ArgumentEqualityExpectation.new(boolean)
+          end
+
+          context "when passed a Boolean" do
+            it "returns true" do
+              expectation.should be_wildcard_match(true)
+              expectation.should be_wildcard_match(false)
+            end
+          end
+
+          context "when not passed a Boolean" do
+            it "returns false" do
+              expectation.should_not be_wildcard_match(:not_a_boolean)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rr/expectations/hash_including_argument_equality_expectation_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+module Expectations
+  describe ArgumentEqualityExpectation, "with HashIncluding argument" do
+    attr_reader :expectation, :expected_hash
+    
+    before do
+      @expected_hash = {:texas => "Austin", :maine => "Augusta"}
+    end
+    
+    describe "#exact_match?" do
+      before do
+        @expectation = ArgumentEqualityExpectation.new(hash_including(expected_hash))
+      end
+      
+      it "returns true when passed in a HashIncluding matcher with the same hash" do
+        expectation.should be_exact_match(RR::WildcardMatchers::HashIncluding.new(expected_hash))
+      end
+      
+      it "returns false when passed in a HashIncluding matcher with a different argument list" do
+        expectation.should_not be_exact_match(RR::WildcardMatchers::HashIncluding.new(:foo => 1))
+      end
+
+      it "returns false otherwise" do
+        expectation.should_not be_exact_match("hello")
+        expectation.should_not be_exact_match(:hello)
+        expectation.should_not be_exact_match(1)
+        expectation.should_not be_exact_match(nil)
+        expectation.should_not be_exact_match(true)
+        expectation.should_not be_exact_match()
+      end
+    end
+
+    describe "#wildcard_match?" do
+      before do
+        @expectation = ArgumentEqualityExpectation.new(hash_including(expected_hash))
+      end
+
+      it "returns true when hash contains same key/values as the expectation" do
+        expectation.should be_wildcard_match(expected_hash)
+      end
+      
+      it "returns true when hash contains at least expectation's key/values" do
+        expectation.should be_wildcard_match(expected_hash.merge(:oregon => "Salem"))
+      end
+      
+      it "returns true when passed the same hash, even after the original is modified" do
+        original_expected_hash = expected_hash.clone
+        expected_hash[:texas] = nil
+        expectation.should be_wildcard_match(original_expected_hash)
+      end
+      
+      it "returns true even if one of the expectation's values is nil" do
+        expectation = ArgumentEqualityExpectation.new(hash_including(:foo => nil))
+        expectation.should be_wildcard_match({:foo => nil})
+      end
+      
+      it "returns false when hash matches only some required key/values" do
+        expectation.should_not be_wildcard_match({:texas => "Austin"})
+      end
+      
+      it "returns false when hash matches all the keys but not all the values" do
+        expectation.should_not be_wildcard_match({:texas => "Austin", :maine => "Portland"})
+      end
+
+      it "returns false when passed a hash that matches all values but not all keys" do
+        expectation.should_not be_wildcard_match({:texas => "Austin", :georgia => "Augusta"})
+      end
+
+      it "returns true when an exact match" do
+        expectation.should be_wildcard_match(hash_including(expected_hash))
+      end
+
+      it "returns false when not passed correct number of arguments" do
+        expectation.should_not be_wildcard_match()
+        expectation.should_not be_wildcard_match(:a, :b)
+      end
+    end
+  end
+end
+end

data/spec/rr/expectations/hash_including_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module WildcardMatchers
+    describe HashIncluding do
+      describe "#inspect" do
+        it "returns hash_including with expected key/values" do
+          expected_hash = {:foo => "bar", :baz => "qux"}
+          matcher = HashIncluding.new(expected_hash)
+          matcher.inspect.should include("hash_including(")
+          matcher.inspect.should include(':foo=>"bar"')
+          matcher.inspect.should include(':baz=>"qux"')
+        end
+      end
+    end
+  end
+end

data/spec/rr/expectations/satisfy_argument_equality_expectation_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+module Expectations
+  describe ArgumentEqualityExpectation, "with Satisfy argument" do
+    attr_reader :expectation, :expectation_proc, :expected_value, :satisfy_matcher
+    
+    before do
+      @expected_value = :foo
+      @expectation_proc = lambda {|argument| argument == expected_value}
+      @satisfy_matcher = satisfy(&expectation_proc)
+      @expectation = ArgumentEqualityExpectation.new(satisfy_matcher)
+    end
+    
+    describe "#exact_match?" do
+      before do
+      end
+      
+      it "returns true when passed a Satisfy matcher with the same proc" do
+        expectation.should be_exact_match(RR::WildcardMatchers::Satisfy.new(expectation_proc))
+      end
+      
+      it "returns false when passed a Satisfy matcher with another proc" do
+        expectation.should_not be_exact_match(RR::WildcardMatchers::Satisfy.new(lambda {}))
+      end
+
+      it "returns false otherwise" do
+        expectation.should_not be_exact_match("hello")
+        expectation.should_not be_exact_match(:hello)
+        expectation.should_not be_exact_match(1)
+        expectation.should_not be_exact_match(nil)
+        expectation.should_not be_exact_match(true)
+        expectation.should_not be_exact_match()
+      end
+    end
+
+    describe "#wildcard_match?" do
+      it "returns true when the proc returns a truthy value" do
+        (!!expectation_proc.call(expected_value)).should be_true
+        expectation.should be_wildcard_match(expected_value)
+      end
+      
+      it "returns false when the proc returns a falsey value" do
+        (!!expectation_proc.call(:bar)).should be_false
+        expectation.should_not be_wildcard_match(:bar)
+      end
+      
+      it "returns true when an exact match" do
+        expectation.should be_wildcard_match(satisfy_matcher)
+      end
+
+      it "returns false when not passed correct number of arguments" do
+        expectation.should_not be_wildcard_match()
+        expectation.should_not be_wildcard_match(:a, :b)
+      end
+    end
+  end
+end
+end