rr 1.1.2.rc1 → 3.0.1

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/expectations/any_argument_expectation_spec.rb

@@ -21,26 +21,26 @@ module RR
         end
 
         it "returns false when comparing with ArgumentEqualityExpectation" do
-          expect(expectation).to_not eq ArgumentEqualityExpectation.new(1)
+          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")
+          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")
+          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

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

@@ -5,7 +5,7 @@ module RR
     describe ArgumentEqualityExpectation do
       attr_reader :expectation
       before do
-        @expectation = ArgumentEqualityExpectation.new(1, 2, 3)
+        @expectation = ArgumentEqualityExpectation.new([1, 2, 3], {})
       end
 
       describe "#expected_arguments" do
@@ -16,30 +16,30 @@ module RR
 
       describe "==" do
         it "returns true when passed in expected_arguments are equal" do
-          expect(expectation).to eq ArgumentEqualityExpectation.new(1, 2, 3)
+          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()
+          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)
+            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")
+            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
@@ -47,26 +47,26 @@ module RR
       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")
+            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")
+            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)
+            expectation.should_not be_wildcard_match([], {})
+            expectation.should_not be_wildcard_match([Object.new, Object.new], {})
           end
         end
       end

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

@@ -7,20 +7,20 @@ module RR
         attr_reader :expectation
 
         before do
-          @expectation = ArgumentEqualityExpectation.new(boolean)
+          @expectation = ArgumentEqualityExpectation.new([boolean], {})
         end
 
         describe "#wildcard_match?" do
           context "when passed a Boolean" do
             it "returns true" do
-              expect(expectation).to be_wildcard_match(true)
-              expect(expectation).to be_wildcard_match(false)
+              expect(expectation).to be_wildcard_match([true], {})
+              expect(expectation).to 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)
+              expectation.should_not be_wildcard_match([:not_a_boolean], {})
             end
           end
         end

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

@@ -11,70 +11,80 @@ module Expectations
 
     describe "#exact_match?" do
       before do
-        @expectation = ArgumentEqualityExpectation.new(hash_including(expected_hash))
+        @expectation = ArgumentEqualityExpectation.new([hash_including(expected_hash)], {})
       end
 
       it "returns true when passed in a HashIncluding matcher with the same hash" do
-        expect(expectation).to be_exact_match(RR::WildcardMatchers::HashIncluding.new(expected_hash))
+        expect(expectation).to 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))
+        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()
+        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))
+        @expectation = ArgumentEqualityExpectation.new([hash_including(expected_hash)],
+                                                       {})
       end
 
       it "returns true when hash contains same key/values as the expectation" do
-        expect(expectation).to be_wildcard_match(expected_hash)
+        expect(expectation).to be_wildcard_match([expected_hash], {})
       end
 
       it "returns true when hash contains at least expectation's key/values" do
-        expect(expectation).to be_wildcard_match(expected_hash.merge(:oregon => "Salem"))
+        expect(expectation).to 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
-        expect(expectation).to be_wildcard_match(original_expected_hash)
+        expect(expectation).to 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))
-        expect(expectation).to be_wildcard_match({:foo => nil})
+        expectation = ArgumentEqualityExpectation.new([hash_including(:foo => nil)],
+                                                      {})
+        expect(expectation).to 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"})
+        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"})
+        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"})
+        expectation.should_not be_wildcard_match([{:texas => "Austin", :georgia => "Augusta"}],
+                                                 {})
       end
 
       it "returns true when an exact match" do
-        expect(expectation).to be_wildcard_match(hash_including(expected_hash))
+        expect(expectation).to 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)
+        expectation.should_not be_wildcard_match([], {})
+        expectation.should_not be_wildcard_match([:a, :b], {})
       end
     end
   end

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

@@ -231,12 +231,6 @@ module RR
                     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}
@@ -383,12 +377,6 @@ module RR
                     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}

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

@@ -2,7 +2,7 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module Integrations
-    describe RSpec1 do
+    describe RSpec2 do
       attr_reader :fixture, :method_name
 
       describe "#setup_mocks_for_rspec" do
@@ -10,7 +10,7 @@ module RR
 
         before do
           @fixture = Object.new
-          fixture.extend RSpec1::Mixin
+          fixture.extend RSpec2::Mixin
           @method_name = :foobar
         end
 
@@ -28,7 +28,7 @@ module RR
 
         before do
           @fixture = Object.new
-          fixture.extend RSpec1::Mixin
+          fixture.extend RSpec2::Mixin
           @method_name = :foobar
         end
 
@@ -47,7 +47,7 @@ module RR
 
         before do
           @fixture = Object.new
-          fixture.extend RSpec1::Mixin
+          fixture.extend RSpec2::Mixin
           @method_name = :foobar
         end
 
@@ -65,21 +65,6 @@ module RR
           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::Integrations::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::Integrations::RSpec::InvocationMatcher).new(nil) { matcher }
-          expect(have_received).to eq matcher
-        end
-      end
     end
   end
 end

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

@@ -11,9 +11,12 @@ module RR
     describe "#record_call" do
       it "should add a call to the list" do
         object = Object.new
-        block = lambda {}
-        space.record_call(object, :to_s, [], block)
-        expect(space.recorded_calls).to eq RR::RecordedCalls.new([[object, :to_s, [], block]])
+        method_name = :to_s
+        arguments = []
+        keyword_arguments = {}
+        space.record_call(object, method_name, arguments, keyword_arguments, lambda {})
+        expect(space.recorded_calls[0]).to eq \
+          RR::RecordedCall.new(object, method_name, arguments, keyword_arguments, lambda {})
       end
     end
 
@@ -200,7 +203,7 @@ module RR
 
       it "should clear the #recorded_calls" do
         object = Object.new
-        space.record_call(object, :to_s, [], nil)
+        space.record_call(object, :to_s, [], {}, nil)
 
         space.reset
         expect(space.recorded_calls).to eq RR::RecordedCalls.new([])

data/spec/suites/rspec_2/unit/spy_verification_spec.rb

@@ -12,7 +12,7 @@ describe RR::SpyVerification do
 
   include_examples "Swapped Space"
 
-  include RR::Adapters::RRMethods
+  include RR::DSL
 
   before(:each) do
     stub(subject).foobar

data/spec/support/adapter.rb

@@ -9,7 +9,7 @@ class Adapter
 
   def appraisal_name
     parts = []
-    parts << (RUBY_VERSION =~ /^1\.8/ ? 'ruby_18' : 'ruby_19')
+    parts << 'ruby_19'
     parts << name
     parts.join('_')
   end