rr 1.2.1 → 3.0.0

data/lib/rr/recorded_call.rb

@@ -1,10 +1,15 @@
 module RR
-  class RecordedCall < Struct.new(:subject, :method_name, :arguments, :block)
+  class RecordedCall < Struct.new(:subject,
+                                  :method_name,
+                                  :arguments,
+                                  :keyword_arguments,
+                                  :block)
     def inspect
-      '[%s, %s, %s, %s]' % [
+      '[%s, %s, %s, %s, %s]' % [
         subject_to_s,
         method_name.inspect,
         arguments.inspect,
+        keyword_arguments.inspect,
         block.inspect
       ]
     end
@@ -13,7 +18,8 @@ module RR
       other.is_a?(self.class) &&
         subject == other.subject &&
         method_name == other.method_name &&
-        arguments == other.arguments
+        arguments == other.arguments &&
+        keyword_arguments == other.keyword_arguments
     end
 
     private

data/lib/rr/recorded_calls.rb

@@ -18,8 +18,12 @@ module RR
       recorded_calls.clear
     end
 
-    def add(subject, method_name, arguments, block)
-      recorded_calls << RecordedCall.new(subject, method_name, arguments, block)
+    def add(subject, method_name, arguments, keyword_arguments, block)
+      recorded_calls << RecordedCall.new(subject,
+                                         method_name,
+                                         arguments,
+                                         keyword_arguments,
+                                         block)
     end
 
     def any?(&block)
@@ -81,22 +85,28 @@ module RR
 
     def match_double_injection(spy_verification)
       lambda do |recorded_call|
-        recorded_call[0] == spy_verification.subject &&
-        recorded_call[1] == spy_verification.method_name
+        recorded_call.subject == spy_verification.subject &&
+          recorded_call.method_name == spy_verification.method_name
       end
     end
 
     def match_argument_expectation(spy_verification)
       lambda do |recorded_call|
-        spy_verification.argument_expectation.exact_match?(*recorded_call[2]) ||
-        spy_verification.argument_expectation.wildcard_match?(*recorded_call[2])
+        expectation = spy_verification.argument_expectation
+        arguments = recorded_call.arguments
+        keyword_arguments = recorded_call.keyword_arguments
+        expectation.exact_match?(arguments, keyword_arguments) ||
+          expectation.wildcard_match?(arguments, keyword_arguments)
       end
     end
 
     def invocation_count_error(spy_verification, matching_recorded_calls)
+      method_name = spy_verification.method_name
+      arguments = spy_verification.argument_expectation.expected_arguments
+      keyword_arguments = spy_verification.argument_expectation.expected_keyword_arguments
       RR::Errors.build_error(RR::Errors::SpyVerificationErrors::InvocationCountError,
         "On subject #{spy_verification.subject.inspect}\n" <<
-        "Expected #{Double.formatted_name(spy_verification.method_name, spy_verification.argument_expectation.expected_arguments)}\n" <<
+        "Expected #{Double.formatted_name(method_name, arguments, keyword_arguments)}\n" <<
         "to be called #{spy_verification.times_matcher.expected_times_message},\n" <<
         "but was called #{matching_recorded_calls.size} times.\n" <<
         "All of the method calls related to Doubles are:\n" <<

data/lib/rr/space.rb

@@ -13,9 +13,15 @@ module RR
       end
       attr_writer :instance
 
-    protected
-      def method_missing(method_name, *args, &block)
-        instance.__send__(method_name, *args, &block)
+      protected
+      if KeywordArguments.fully_supported?
+        def method_missing(method_name, *args, **kwargs, &block)
+          instance.__send__(method_name, *args, **kwargs, &block)
+        end
+      else
+        def method_missing(method_name, *args, &block)
+          instance.__send__(method_name, *args, &block)
+        end
       end
     end
 
@@ -79,8 +85,12 @@ module RR
       Injections::DoubleInjection.reset_double(class << subject; self; end, method_name)
     end
 
-    def record_call(subject, method_name, arguments, block)
-      @recorded_calls.add(subject, method_name, arguments, block)
+    def record_call(subject, method_name, arguments, keyword_arguments, block)
+      @recorded_calls.add(subject,
+                          method_name,
+                          arguments,
+                          keyword_arguments,
+                          block)
     end
 
     def blank_slate_whitelist

data/lib/rr/version.rb

@@ -1,4 +1,4 @@
 module RR
-  VERSION = '1.2.1'.freeze
+  VERSION = '3.0.0'.freeze
   def self.version; VERSION; end
 end

data/lib/rr/without_autohook.rb

@@ -6,6 +6,8 @@ require 'rr/core_ext/array'
 require 'rr/core_ext/range'
 require 'rr/core_ext/regexp'
 
+require 'rr/keyword_arguments'
+
 require 'rr/class_instance_method_defined'
 require 'rr/blank_slate'
 
@@ -51,7 +53,6 @@ require 'rr/method_dispatches/method_missing_dispatch'
 require 'rr/hash_with_object_id_key'
 require 'rr/recorded_call'
 require 'rr/recorded_calls'
-require 'rr/proc_from_block'
 
 require 'rr/double_definitions/double_definition_create_blank_slate'
 require 'rr/double_definitions/double_definition_create'

data/rr.gemspec

@@ -29,4 +29,9 @@ Gem::Specification.new do |gem|
   ].to_a
 
   gem.require_paths = ['lib']
+
+  gem.add_development_dependency("bundler")
+  gem.add_development_dependency("rake")
+  gem.add_development_dependency("test-unit")
+  gem.add_development_dependency("test-unit-rr")
 end

data/spec/suites.yml

@@ -1,13 +1,3 @@
-18:
-  rvm_versions:
-    - name: 1.8.7
-  suites:
-    - name: rspec_1
-      desc: 'RSpec 1'
-    - name: rspec_1_rails_2
-      desc: 'RSpec 1 + Rails 2'
-  env:
-    SPEC_OPTS: '--require $PWD/spec/custom_formatter_for_rspec --format CustomFormatterForRSpec --backtrace'
 19:
   rvm_versions:
     - name: 1.9.3
@@ -16,9 +6,5 @@
   suites:
     - name: rspec_2
       desc: 'RSpec 2'
-    - name: rspec_2_rails_3
-      desc: 'RSpec 2 + Rails 3'
-    - name: rspec_2_rails_4
-      desc: 'RSpec 2 + Rails 4'
   env:
-    SPEC_OPTS: '--require $PWD/spec/custom_formatter_for_rspec_2 --format CustomFormatterForRSpec2 --backtrace --fail-fast'
+    SPEC_OPTS: '--require $PWD/spec/custom_formatter_for_rspec_2 --format CustomFormatterForRSpec2 --backtrace'

data/spec/suites/rspec_2/unit/double_definitions/double_definition_create_spec.rb

@@ -223,7 +223,7 @@ module RR
 
               describe "#subject.method_name being called" do
                 it "returns the return value of the Double#returns block" do
-                  double_definition_create.call(:foobar, 1, 2) {:baz}
+                  double_definition_create.call(:foobar, [1, 2], {}) {:baz}
                   expect(subject.foobar(1, 2)).to eq :baz
                 end
               end
@@ -254,7 +254,7 @@ module RR
                       original_method_called = true
                     end
                   end
-                  double_definition_create.call(:foobar, 1, 2)
+                  double_definition_create.call(:foobar, [1, 2], {})
                   subject.foobar(1, 2)
                   expect(original_method_called).to be_true
                 end
@@ -264,7 +264,7 @@ module RR
                     def subject.foobar(*args)
                       :baz;
                     end
-                    double_definition_create.call(:foobar, 1, 2)
+                    double_definition_create.call(:foobar, [1, 2], {})
                     expect(subject.foobar(1, 2)).to eq :baz
                   end
                 end
@@ -279,7 +279,7 @@ module RR
                   end
 
                   it "calls the block with the return value of the original method" do
-                    double_definition_create.call(:foobar, 1, 2) do |value|
+                    double_definition_create.call(:foobar, [1, 2], {}) do |value|
                       mock(value).a_method {99}
                       value
                     end
@@ -288,7 +288,7 @@ module RR
                   end
 
                   it "returns the return value of the block" do
-                    double_definition_create.call(:foobar, 1, 2) do |value|
+                    double_definition_create.call(:foobar, [1, 2], {}) do |value|
                       :something_else
                     end
                     expect(subject.foobar(1, 2)).to eq :something_else
@@ -306,7 +306,7 @@ module RR
 
               context "when not passed a block" do
                 it "returns nil" do
-                  double_definition_create.call(:foobar)
+                  double_definition_create.call(:foobar, [], {})
                   expect(subject.foobar).to be_nil
                 end
               end
@@ -314,7 +314,7 @@ module RR
               context "when passed a block" do
                 describe "#subject.method_name being called" do
                   it "returns the return value of the block" do
-                    double_definition_create.call(:foobar) {:baz}
+                    double_definition_create.call(:foobar, [], {}) {:baz}
                     expect(subject.foobar).to eq :baz
                   end
                 end
@@ -323,7 +323,7 @@ module RR
               context "when not passed args" do
                 describe "#subject.method_name being called with any arguments" do
                   it "invokes the implementation of the Stub" do
-                    double_definition_create.call(:foobar) {:baz}
+                    double_definition_create.call(:foobar, [], {}) {:baz}
                     expect(subject.foobar(1, 2)).to eq :baz
                     expect(subject.foobar()).to eq :baz
                     expect(subject.foobar([])).to eq :baz
@@ -334,14 +334,14 @@ module RR
               context "when passed args" do
                 describe "#subject.method_name being called with the passed-in arguments" do
                   it "invokes the implementation of the Stub" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, [1, 2], {}) {:baz}
                     expect(subject.foobar(1, 2)).to eq :baz
                   end
                 end
 
                 describe "#subject.method_name being called with different arguments" do
                   it "raises a DoubleNotFoundError" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, [1, 2], {}) {:baz}
                     expect {
                       subject.foobar
                     }.to raise_error(RR::Errors::DoubleNotFoundError)
@@ -362,7 +362,7 @@ module RR
               context "when not passed a block" do
                 describe "#subject.method_name being called" do
                   it "invokes the original implementanion" do
-                    double_definition_create.call(:foobar)
+                    double_definition_create.call(:foobar, [], {})
                     expect(subject.foobar).to eq :original_return_value
                   end
                 end
@@ -372,7 +372,7 @@ module RR
                 describe "#subject.method_name being called" do
                   it "invokes the original implementanion and invokes the block with the return value of the original implementanion" do
                     passed_in_value = nil
-                    double_definition_create.call(:foobar) do |original_return_value|
+                    double_definition_create.call(:foobar, [], {}) do |original_return_value|
                       passed_in_value = original_return_value
                     end
                     subject.foobar
@@ -380,7 +380,7 @@ module RR
                   end
 
                   it "returns the return value of the block" do
-                    double_definition_create.call(:foobar) do |original_return_value|
+                    double_definition_create.call(:foobar, [], {}) do |original_return_value|
                       :new_return_value
                     end
                     expect(subject.foobar).to eq :new_return_value
@@ -391,14 +391,14 @@ module RR
               context "when passed args" do
                 describe "#subject.method_name being called with the passed-in arguments" do
                   it "invokes the implementation of the Stub" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, [1, 2], {}) {:baz}
                     expect(subject.foobar(1, 2)).to eq :baz
                   end
                 end
 
                 describe "#subject.method_name being called with different arguments" do
                   it "raises a DoubleNotFoundError" do
-                    double_definition_create.call(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, [1, 2], {}) {:baz}
                     expect {
                       subject.foobar
                     }.to raise_error(RR::Errors::DoubleNotFoundError)
@@ -416,7 +416,7 @@ module RR
             context "when not passed args" do
               describe "#subject.method_name being called with any arguments" do
                 it "raises a TimesCalledError" do
-                  double_definition_create.call(:foobar)
+                  double_definition_create.call(:foobar, [], {})
                   expect { subject.foobar }.to raise_error(RR::Errors::TimesCalledError)
                   expect { subject.foobar(1, 2) }.to raise_error(RR::Errors::TimesCalledError)
                 end
@@ -426,14 +426,14 @@ module RR
             context "when passed args" do
               describe "#subject.method_name being called with the passed-in arguments" do
                 it "raises a TimesCalledError" do
-                  double_definition_create.call(:foobar, 1, 2)
+                  double_definition_create.call(:foobar, [1, 2], {})
                   expect { subject.foobar(1, 2) }.to raise_error(RR::Errors::TimesCalledError)
                 end
               end
 
               describe "#subject.method_name being called with different arguments" do
                 it "raises a DoubleNotFoundError" do
-                  double_definition_create.call(:foobar, 1, 2)
+                  double_definition_create.call(:foobar, [1, 2], {})
                   expect { subject.foobar() }.to raise_error(RR::Errors::DoubleNotFoundError)
                 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