rr 1.0.5 → 1.1.0.rc1

data/spec/suites/rspec_2/unit/adapters/rspec/invocation_matcher_spec.rb

@@ -0,0 +1,297 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
+
+module RR
+  module Adapters
+    module RSpec
+      describe InvocationMatcher do
+        describe "matching against a method with no doubles" do
+          before do
+            @matcher = InvocationMatcher.new(:foobar)
+            @result = @matcher.matches?(Object.new)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "defining an expectation using a method invocation" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            subject.foobar(:args)
+            @result = InvocationMatcher.new.foobar(:args).matches?(subject)
+          end
+
+          it "uses the invoked method as the expected method" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching against a stubbed method that was never called" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            @matcher = InvocationMatcher.new(:foobar)
+            @result = @matcher.matches?(subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching against a stubbed method that was called once" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            subject.foobar
+            @result = InvocationMatcher.new(:foobar).matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching against a stubbed method that was called with unexpected arguments" do
+          subject { Object.new }
+
+          before do
+            @args = %w(one two)
+            stub(subject).foobar
+            subject.foobar(:other)
+            @result = InvocationMatcher.new(:foobar).with(*@args).matches?(subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching against a stubbed method that was called with expected arguments" do
+          subject { Object.new }
+
+          before do
+            @args = %w(one two)
+            stub(subject).foobar
+            subject.foobar(*@args)
+            @result = InvocationMatcher.new(:foobar).with(*@args).matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "defining a fulfilled argument expectation using a method invocation" do
+          subject { Object.new }
+
+          before do
+            @args = %w(one two)
+            stub(subject).foobar
+            subject.foobar(*@args)
+            @result = InvocationMatcher.new.foobar(*@args).matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "defining an unfulfilled argument expectation using a method invocation" do
+          subject { Object.new }
+
+          before do
+            @args = %w(one two)
+            stub(subject).foobar
+            subject.foobar(:other)
+            @result = InvocationMatcher.new.foobar(*@args).matches?(subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching against a stubbed method that was called more than once" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            2.times { subject.foobar }
+            @result = InvocationMatcher.new(:foobar).twice.matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching a stubbed method with any arguments" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            subject.foobar(:args)
+            @result = InvocationMatcher.new(:foobar).with_any_args.matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching a stubbed method with no arguments when arguments are not provided" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            subject.foobar
+            @result = InvocationMatcher.new(:foobar).with_no_args.matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching a stubbed method with no arguments when arguments are provided" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            subject.foobar(:args)
+            @result = InvocationMatcher.new(:foobar).with_no_args.matches?(subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called twice when expected once" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            2.times { subject.foobar }
+            @matcher = InvocationMatcher.new(:foobar).times(1)
+            @result = @matcher.matches?(subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called twice when expected twice" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            2.times { subject.foobar }
+            @result = InvocationMatcher.new(:foobar).times(2).matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching a method that was called twice when any number of times" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            2.times { subject.foobar }
+            @result = InvocationMatcher.new(:foobar).any_number_of_times.matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching a method that was called three times when expected at most twice" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            3.times { subject.foobar }
+            @result = InvocationMatcher.new(:foobar).at_most(2).matches?(subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called once when expected at most twice" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            subject.foobar
+            @result = InvocationMatcher.new(:foobar).at_most(2).matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "matching a method that was called once when expected at least twice" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            subject.foobar
+            @result = InvocationMatcher.new(:foobar).at_least(2).matches?(subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called three times when expected at least twice" do
+          subject { Object.new }
+
+          before do
+            stub(subject).foobar
+            3.times { subject.foobar }
+            @result = InvocationMatcher.new(:foobar).at_least(2).matches?(subject)
+          end
+
+          it "does match" do
+            expect(@result).to be
+          end
+        end
+
+        describe "that does not match" do
+          before do
+            @error = Object.new
+            @message = 'Verification error message'
+            stub(RR::Space.instance.recorded_calls).match_error { @error }
+            stub(@error).message { @message }
+
+            @matcher = InvocationMatcher.new(:foobar)
+            @result = @matcher.matches?(Object.new)
+          end
+
+          it "returns false when matching" do
+            @result.should_not be
+          end
+
+          it "returns a failure messsage" do
+            expect(@matcher.failure_message).to eq @message
+          end
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/adapters/rspec_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Adapters
+    describe RSpec1 do
+      attr_reader :fixture, :method_name
+
+      describe "#setup_mocks_for_rspec" do
+        subject { Object.new }
+
+        before do
+          @fixture = Object.new
+          fixture.extend RSpec1::AdapterMethods
+          @method_name = :foobar
+        end
+
+        it "resets the double_injections" do
+          stub(subject).foobar
+          ::RR::Injections::DoubleInjection.instances.should_not be_empty
+
+          fixture.setup_mocks_for_rspec
+          expect(::RR::Injections::DoubleInjection.instances).to be_empty
+        end
+      end
+
+      describe "#verify_mocks_for_rspec" do
+        subject { Object.new }
+
+        before do
+          @fixture = Object.new
+          fixture.extend RSpec1::AdapterMethods
+          @method_name = :foobar
+        end
+
+        it "verifies the double_injections" do
+          mock(subject).foobar
+
+          expect {
+            fixture.verify_mocks_for_rspec
+          }.to raise_error(::RR::Errors::TimesCalledError)
+          expect(::RR::Injections::DoubleInjection.instances).to be_empty
+        end
+      end
+
+      describe "#teardown_mocks_for_rspec" do
+        subject { Object.new }
+
+        before do
+          @fixture = Object.new
+          fixture.extend RSpec1::AdapterMethods
+          @method_name = :foobar
+        end
+
+        it "resets the double_injections" do
+          stub(subject).foobar
+          ::RR::Injections::DoubleInjection.instances.should_not be_empty
+
+          fixture.teardown_mocks_for_rspec
+          expect(::RR::Injections::DoubleInjection.instances).to be_empty
+        end
+      end
+
+      describe "#trim_backtrace" do
+        it "does not set trim_backtrace" do
+          expect(RR.trim_backtrace).to eq false
+        end
+      end
+
+      describe '#have_received' do
+        it "creates an invocation matcher with a method name" do
+          method  = :test
+          matcher = 'fake'
+          mock(RR::Adapters::RSpec::InvocationMatcher).new(method) { matcher }
+          expect(have_received(method)).to eq matcher
+        end
+
+        it "creates an invocation matcher without a method name" do
+          matcher = 'fake'
+          mock(RR::Adapters::RSpec::InvocationMatcher).new(nil) { matcher }
+          expect(have_received).to eq matcher
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/core_ext/array_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Array do
+  include WildcardMatcherMatchers
+
+  describe '#wildcard_match?' do
+    context 'when this Array has items that respond to #wildcard_match?' do
+      subject { [hash_including({:foo => 'bar'})] }
+
+      it "returns true if all items in the given Array wildcard-match corresponding items in this Array" do
+        should wildcard_match([{:foo => 'bar', :baz => 'quux'}])
+      end
+
+      it "returns true if any items in the given Array do not wildcard-match corresponding items in this Array" do
+        should_not wildcard_match([{:foo => 'bat', :baz => 'quux'}])
+      end
+    end
+
+    context 'when this Array has items that do not respond to #wildcard_match?' do
+      subject { [:a_symbol] }
+
+      it "returns true if all items in the given Array equal-match corresponding items in this Array" do
+        should wildcard_match([:a_symbol])
+      end
+
+      it "returns true if any items in the given Array do not equal-match corresponding items in this Array" do
+        should_not wildcard_match([:another_symbol])
+      end
+    end
+
+    context 'when not given an Array' do
+      subject { [{:foo => 'bar'}] }
+
+      it "returns false" do
+        should_not wildcard_match(:something_else)
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/core_ext/enumerable_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Enumerable do
+  include WildcardMatcherMatchers
+
+  let(:klass) {
+    Class.new do
+      include Enumerable
+
+      def initialize(*items)
+        @arr = items
+      end
+
+      def each(&block)
+        @arr.each(&block)
+      end
+    end
+  }
+
+  describe '#wildcard_match?' do
+    context 'when this Enumerable has items that respond to #wildcard_match?' do
+      subject { klass.new(hash_including({:foo => 'bar'})) }
+
+      it "returns true if all items in the given Enumerable wildcard-match corresponding items in this Enumerable" do
+        should wildcard_match([{:foo => 'bar', :baz => 'quux'}])
+      end
+
+      it "returns true if any items in the given Enumerable do not wildcard-match corresponding items in this Enumerable" do
+        should_not wildcard_match([{:foo => 'bat', :baz => 'quux'}])
+      end
+    end
+
+    context 'when this Enumerable has items that do not respond to #wildcard_match?' do
+      subject { klass.new(:a_symbol) }
+
+      it "returns true if all items in the given Enumerable equal-match corresponding items in this Enumerable" do
+        should wildcard_match([:a_symbol])
+      end
+
+      it "returns true if any items in the given Enumerable do not equal-match corresponding items in this Enumerable" do
+        should_not wildcard_match([:another_symbol])
+      end
+    end
+
+    if RUBY_VERSION =~ /^1.8/
+      context 'when the Enumerable is a String' do
+        subject { 'foo' }
+
+        it "returns true if the String is exactly equal to the given String" do
+          should wildcard_match('foo')
+        end
+
+        it "returns false if the string is not exactly equal to the given String" do
+          should_not wildcard_match('bar')
+        end
+
+        context 'whose #== method has been proxied' do
+          before do
+            @r1 = 'x'
+            @r2 = 'y'
+            mock.proxy(@r1) == @r1
+            mock.proxy(@r1) == @r2
+          end
+
+          it "doesn't blow up with a recursive loop error" do
+            @r1 == @r1
+            @r1 == @r2
+          end
+        end
+      end
+    end
+
+    context 'when not given an Enumerable' do
+      subject { klass.new({:foo => 'bar'}) }
+
+      it "returns false" do
+        should_not wildcard_match(:something_else)
+      end
+    end
+  end
+end