rr 1.1.1 → 3.0.0

data/spec/suites/rspec_2/unit/dsl/double_creators_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  describe DSL do
+    subject { Object.new }
+
+    after(:each) do
+      RR.reset
+    end
+
+    describe "normal strategy definitions" do
+      attr_reader :strategy_method_name
+
+      def call_strategy(*args, &block)
+        __send__(strategy_method_name, *args, &block)
+      end
+
+      describe "#mock" do
+        before do
+          @strategy_method_name = :mock
+        end
+
+        context "when passing no args" do
+          it "returns a DoubleDefinitionCreate" do
+            expect(call_strategy.class).to eq RR::DoubleDefinitions::DoubleDefinitionCreate
+          end
+        end
+
+        context "when passed a method_name argument" do
+          it "creates a mock Double for method" do
+            double_definition = mock(subject, :foobar).returns {:baz}
+            expect(double_definition.times_matcher).to eq RR::TimesCalledMatchers::IntegerMatcher.new(1)
+            expect(double_definition.argument_expectation.class).to eq RR::Expectations::ArgumentEqualityExpectation
+            expect(double_definition.argument_expectation.expected_arguments).to eq []
+            expect(subject.foobar).to eq :baz
+          end
+        end
+      end
+
+      describe "#stub" do
+        before do
+          @strategy_method_name = :stub
+        end
+
+        context "when passing no args" do
+          it "returns a DoubleDefinitionCreate" do
+            expect(call_strategy.class).to eq RR::DoubleDefinitions::DoubleDefinitionCreate
+          end
+        end
+
+        context "when passed a method_name argument" do
+          it "creates a stub Double for method when passed a method_name argument" do
+            double_definition = stub(subject, :foobar).returns {:baz}
+            expect(double_definition.times_matcher).to eq RR::TimesCalledMatchers::AnyTimesMatcher.new
+            expect(double_definition.argument_expectation.class).to eq RR::Expectations::AnyArgumentExpectation
+            expect(subject.foobar).to eq :baz
+          end
+        end
+      end
+
+      describe "#dont_allow" do
+        before do
+          @strategy_method_name = :dont_allow
+        end
+
+        context "when passing no args" do
+          it "returns a DoubleDefinitionCreate" do
+            expect(call_strategy.class).to eq RR::DoubleDefinitions::DoubleDefinitionCreate
+          end
+        end
+
+        context "when passed a method_name argument_expectation" do
+          it "creates a mock Double for method" do
+            double_definition = dont_allow(subject, :foobar)
+            expect(double_definition.times_matcher).to eq RR::TimesCalledMatchers::NeverMatcher.new
+            expect(double_definition.argument_expectation.class).to eq RR::Expectations::AnyArgumentExpectation
+
+            expect {
+              subject.foobar
+            }.to raise_error(RR::Errors::TimesCalledError)
+            RR.reset
+          end
+        end
+      end
+    end
+
+    describe "! strategy definitions" do
+      attr_reader :strategy_method_name
+      def call_strategy(*args, &definition_eval_block)
+        __send__(strategy_method_name, *args, &definition_eval_block)
+      end
+
+      describe "#mock!" do
+        before do
+          @strategy_method_name = :mock!
+        end
+
+        context "when passed a method_name argument" do
+          it "sets #verification_strategy to Mock" do
+            proxy = mock!(:foobar)
+            expect(proxy.double_definition_create.verification_strategy.class).to eq RR::DoubleDefinitions::Strategies::Verification::Mock
+          end
+        end
+      end
+
+      describe "#stub!" do
+        before do
+          @strategy_method_name = :stub!
+        end
+
+        context "when passed a method_name argument" do
+          it "sets #verification_strategy to Stub" do
+            proxy = stub!(:foobar)
+            expect(proxy.double_definition_create.verification_strategy.class).to eq RR::DoubleDefinitions::Strategies::Verification::Stub
+          end
+        end
+      end
+
+      describe "#dont_allow!" do
+        before do
+          @strategy_method_name = :dont_allow!
+        end
+
+        context "when passed a method_name argument" do
+          it "sets #verification_strategy to DontAllow" do
+            proxy = dont_allow!(:foobar)
+            expect(proxy.double_definition_create.verification_strategy.class).to eq RR::DoubleDefinitions::Strategies::Verification::DontAllow
+          end
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/dsl/space_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  describe DSL do
+    attr_reader :space, :subject_1, :subject_2, :method_name
+
+    include_examples "Swapped Space"
+
+    include RR::DSL
+
+    before do
+      @subject_1 = Object.new
+      @subject_2 = Object.new
+      @method_name = :foobar
+    end
+
+    describe "#verify" do
+      it "aliases #rr_verify" do
+        expect(DSL.instance_method("verify")).to eq DSL.instance_method("rr_verify")
+      end
+    end
+
+    describe "#rr_verify" do
+      it "verifies and deletes the double_injections" do
+        double_1 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
+        double_1_verify_calls = 0
+        double_1_reset_calls = 0
+        (
+        class << double_1;
+          self;
+        end).class_eval do
+          define_method(:verify) do ||
+            double_1_verify_calls += 1
+          end
+          define_method(:reset) do ||
+            double_1_reset_calls += 1
+          end
+        end
+        double_2 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
+        double_2_verify_calls = 0
+        double_2_reset_calls = 0
+        ( class << double_2; self; end).class_eval do
+          define_method(:verify) do ||
+            double_2_verify_calls += 1
+          end
+          define_method(:reset) do ||
+            double_2_reset_calls += 1
+          end
+        end
+
+        rr_verify
+        expect(double_1_verify_calls).to eq 1
+        expect(double_2_verify_calls).to eq 1
+        expect(double_1_reset_calls).to eq 1
+        expect(double_1_reset_calls).to eq 1
+      end
+    end
+
+    describe "#reset" do
+      it "aliases #rr_reset" do
+        expect(DSL.instance_method("reset")).to eq DSL.instance_method("rr_reset")
+      end
+    end
+
+    describe "#rr_reset" do
+      it "removes the ordered doubles" do
+        mock(subject_1).foobar1.ordered
+        mock(subject_2).foobar2.ordered
+
+        ::RR::Injections::DoubleInjection.instances.should_not be_empty
+
+        rr_reset
+        ::RR::Injections::DoubleInjection.instances
+        expect(::RR::Injections::DoubleInjection.instances).to be_empty
+      end
+
+      it "resets all double_injections" do
+        double_1 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
+        double_1_reset_calls = 0
+        ( class << double_1; self; end).class_eval do
+          define_method(:reset) do ||
+            double_1_reset_calls += 1
+          end
+        end
+        double_2 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
+        double_2_reset_calls = 0
+        ( class << double_2; self; end).class_eval do
+          define_method(:reset) do ||
+            double_2_reset_calls += 1
+          end
+        end
+
+        rr_reset
+        expect(double_1_reset_calls).to eq 1
+        expect(double_2_reset_calls).to eq 1
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/dsl/wildcard_matchers_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  describe DSL do
+    include DSL
+
+    describe "#anything" do
+      it "returns an Anything matcher" do
+        expect(anything).to eq RR::WildcardMatchers::Anything.new
+      end
+
+      it "rr_anything returns an Anything matcher" do
+        expect(rr_anything).to eq RR::WildcardMatchers::Anything.new
+      end
+    end
+
+    describe "#is_a" do
+      it "returns an IsA matcher" do
+        expect(is_a(Integer)).to eq RR::WildcardMatchers::IsA.new(Integer)
+      end
+
+      it "rr_is_a returns an IsA matcher" do
+        expect(rr_is_a(Integer)).to eq RR::WildcardMatchers::IsA.new(Integer)
+      end
+    end
+
+    describe "#numeric" do
+      it "returns an Numeric matcher" do
+        expect(numeric).to eq RR::WildcardMatchers::Numeric.new
+      end
+
+      it "rr_numeric returns an Numeric matcher" do
+        expect(rr_numeric).to eq RR::WildcardMatchers::Numeric.new
+      end
+    end
+
+    describe "#boolean" do
+      it "returns an Boolean matcher" do
+        expect(boolean).to eq RR::WildcardMatchers::Boolean.new
+      end
+
+      it "rr_boolean returns an Boolean matcher" do
+        expect(rr_boolean).to eq RR::WildcardMatchers::Boolean.new
+      end
+    end
+
+    describe "#duck_type" do
+      it "returns a DuckType matcher" do
+        expect(duck_type(:one, :two)).to eq RR::WildcardMatchers::DuckType.new(:one, :two)
+      end
+
+      it "rr_duck_type returns a DuckType matcher" do
+        expect(rr_duck_type(:one, :two)).to eq RR::WildcardMatchers::DuckType.new(:one, :two)
+      end
+    end
+  end
+
+  describe "#any_times" do
+    it "returns an AnyTimesMatcher" do
+      expect(any_times).to eq RR::TimesCalledMatchers::AnyTimesMatcher.new
+    end
+
+    it "rr_any_times returns an AnyTimesMatcher" do
+      expect(rr_any_times).to eq RR::TimesCalledMatchers::AnyTimesMatcher.new
+    end
+  end
+end

data/spec/suites/rspec_2/unit/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")
+
+          expect(backtrace).to include("lib/rr")
+        end
+
+        it "returns custom backtrace when backtrace is set" do
+          error = RRError.new
+          custom_backtrace = caller
+          error.backtrace = custom_backtrace
+          expect(error.backtrace).to eq 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
+          expect(error.backtrace.first).to include(__FILE__)
+          expect(error.backtrace.first).to include(expected_line.to_s)
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/expectations/any_argument_expectation_spec.rb

@@ -0,0 +1,48 @@
+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
+          expect(expectation.expected_arguments).to eq []
+        end
+      end
+
+      describe "==" do
+        it "returns true when comparing with another AnyArgumentExpectation" do
+          expect(expectation).to eq AnyArgumentExpectation.new
+        end
+
+        it "returns false when comparing with ArgumentEqualityExpectation" do
+          expect(expectation).to_not eq 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
+          expect(expectation).to be_wildcard_match([1, 2, 3], {})
+          expect(expectation).to be_wildcard_match(["whatever"], {})
+          expect(expectation).to be_wildcard_match(["whatever", "else"], {})
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/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/suites/rspec_2/unit/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
+          expect(expectation.expected_arguments).to eq [1, 2, 3]
+        end
+      end
+
+      describe "==" do
+        it "returns true when passed in expected_arguments are equal" do
+          expect(expectation).to eq ArgumentEqualityExpectation.new([1, 2, 3], {})
+        end
+
+        it "returns false when passed in expected_arguments are not equal" do
+          expect(expectation).to_not eq ArgumentEqualityExpectation.new([1, 2], {})
+          expect(expectation).to_not eq ArgumentEqualityExpectation.new([1], {})
+          expect(expectation).to_not eq ArgumentEqualityExpectation.new([:something], {})
+          expect(expectation).to_not eq ArgumentEqualityExpectation.new([], {})
+        end
+      end
+
+      describe "#exact_match?" do
+        context "when all arguments exactly match" do
+          it "returns true" do
+            expect(expectation).to 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], {})
+            expect(expectation).to 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
+            expect(ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2)).to eq ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2)
+
+            mock.proxy(@predicate1) == @predicate1
+            mock.proxy(@predicate2) == @predicate3
+            expect(ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2)).to_not eq 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
+            expect(ArgumentEqualityFunctionalFixture.new(@predicate1, @predicate2)).to 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