rr 1.1.2 → 3.0.2

data/lib/rr/double.rb

@@ -4,14 +4,20 @@ module RR
   # and the implementation.
   class Double
     extend(Module.new do
-      def formatted_name(method_name, args)
-        formatted_errors = args.collect {|arg| arg.inspect}.join(', ')
+      def formatted_name(method_name, args, kwargs)
+        formatted_arguments =
+          args.collect {|arg| arg.inspect} +
+          kwargs.collect {|keyword, value| "#{keyword}: #{value.inspect}"}
+        formatted_errors = formatted_arguments.join(', ')
         "#{method_name}(#{formatted_errors})"
       end
 
       def list_message_part(doubles)
         doubles.collect do |double|
-          "- #{formatted_name(double.method_name, double.expected_arguments)}"
+          name = formatted_name(double.method_name,
+                                double.expected_arguments,
+                                double.expected_keyword_arguments)
+          "- #{name}"
         end.join("\n")
       end
     end)
@@ -32,14 +38,14 @@ module RR
 
     # Double#exact_match? returns true when the passed in arguments
     # exactly match the ArgumentEqualityExpectation arguments.
-    def exact_match?(*arguments)
-      definition.exact_match?(*arguments)
+    def exact_match?(arguments, keyword_arguments)
+      definition.exact_match?(arguments, keyword_arguments)
     end
 
     # Double#wildcard_match? returns true when the passed in arguments
     # wildcard match the ArgumentEqualityExpectation arguments.
-    def wildcard_match?(*arguments)
-      definition.wildcard_match?(*arguments)
+    def wildcard_match?(arguments, keyword_arguments)
+      definition.wildcard_match?(arguments, keyword_arguments)
     end
 
     # Double#attempt? returns true when the
@@ -74,18 +80,26 @@ module RR
       argument_expectation.expected_arguments
     end
 
+    # The keyword arguments that this Double expects
+    def expected_keyword_arguments
+      verify_argument_expectation_is_set
+      argument_expectation.expected_keyword_arguments
+    end
+
     # The TimesCalledMatcher for the TimesCalledExpectation
     def times_matcher
       definition.times_matcher
     end
 
     def formatted_name
-      self.class.formatted_name(method_name, expected_arguments)
+      self.class.formatted_name(method_name,
+                                expected_arguments,
+                                expected_keyword_arguments)
     end
 
-    def method_call(args)
+    def method_call(args, kwargs)
       if verbose?
-        puts Double.formatted_name(method_name, args)
+        puts Double.formatted_name(method_name, args, kwargs)
       end
       times_called_expectation.attempt if definition.times_matcher
       space.verify_ordered_double(self) if ordered?
@@ -148,6 +162,10 @@ module RR
       definition.argument_expectation.expected_arguments
     end
 
+    def kwargs
+      definition.argument_expectation.expected_keyword_arguments
+    end
+
     def argument_expectation
       definition.argument_expectation
     end

data/lib/rr/double_definitions/double_definition.rb

@@ -36,16 +36,26 @@ module RR
       end
 
       module ArgumentDefinitionConstructionMethods
-        # Double#with sets the expectation that the Double will receive
-        # the passed in arguments.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.with(1, 2) {:return_value}
-        def with(*args, &return_value_block)
-          @argument_expectation = Expectations::ArgumentEqualityExpectation.new(*args)
-          install_method_callback return_value_block
-          self
+        if KeywordArguments.fully_supported?
+          # Double#with sets the expectation that the Double will receive
+          # the passed in arguments.
+          #
+          # Passing in a block sets the return value.
+          #
+          #   mock(subject).method_name.with(1, 2) {:return_value}
+          def with(*args, **kwargs, &return_value_block)
+            @argument_expectation =
+              Expectations::ArgumentEqualityExpectation.new(args, kwargs)
+            install_method_callback return_value_block
+            self
+          end
+        else
+          def with(*args, &return_value_block)
+            @argument_expectation =
+              Expectations::ArgumentEqualityExpectation.new(args, {})
+            install_method_callback return_value_block
+            self
+          end
         end
 
         # Double#with_any_args sets the expectation that the Double can receive
@@ -67,7 +77,8 @@ module RR
         #
         #   mock(subject).method_name.with_no_args {:return_value}
         def with_no_args(&return_value_block)
-          @argument_expectation = Expectations::ArgumentEqualityExpectation.new()
+          @argument_expectation =
+            Expectations::ArgumentEqualityExpectation.new([], {})
           install_method_callback return_value_block
           self
         end
@@ -298,18 +309,18 @@ module RR
           @verbose ? true : false
         end
 
-        def exact_match?(*arguments)
+        def exact_match?(arguments, keyword_arguments)
           unless @argument_expectation
             raise RR::Errors.build_error(:DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}")
           end
-          @argument_expectation.exact_match?(*arguments)
+          @argument_expectation.exact_match?(arguments, keyword_arguments)
         end
 
-        def wildcard_match?(*arguments)
+        def wildcard_match?(arguments, keyword_arguments)
           unless @argument_expectation
             raise RR::Errors.build_error(:DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}")
           end
-          @argument_expectation.wildcard_match?(*arguments)
+          @argument_expectation.wildcard_match?(arguments, keyword_arguments)
         end
 
         def terminal?
@@ -320,7 +331,19 @@ module RR
         end
 
         def expected_arguments
-          argument_expectation ? argument_expectation.expected_arguments : []
+          if argument_expectation
+            argument_expectation.expected_arguments
+          else
+            []
+          end
+        end
+
+        def expected_keyword_arguments
+          if argument_expectation
+            argument_expectation.expected_keyword_arguments
+          else
+            {}
+          end
         end
 
         def implementation_is_original_method?

data/lib/rr/double_definitions/double_definition_create.rb

@@ -30,11 +30,11 @@ module RR
         @double_injection_strategy = self.class.default_double_injection_strategy.call(self)
       end
 
-      def call(method_name, *args, &handler)
+      def call(method_name, args, kwargs, &handler)
         definition = DoubleDefinition.new(self)
-        verification_strategy.call(definition, method_name, args, handler)
-        implementation_strategy.call(definition, method_name, args, handler)
-        double_injection_strategy.call(definition, method_name, args, handler)
+        verification_strategy.call(definition, method_name, args, kwargs, handler)
+        implementation_strategy.call(definition, method_name, args, kwargs, handler)
+        double_injection_strategy.call(definition, method_name, args, kwargs, handler)
         definition
       end
 
@@ -81,7 +81,7 @@ module RR
             self
           elsif method_name
             # TODO: Pass in arguments.
-            call(method_name)
+            call(method_name, [], {})
           else
             DoubleDefinitionCreateBlankSlate.new(self, &definition_eval_block)
           end

data/lib/rr/double_definitions/double_definition_create_blank_slate.rb

@@ -14,13 +14,19 @@ module RR
         end
       end
 
-      def method_missing(method_name, *args, &block)
-        @double_definition_create.call(method_name, *args, &block)
+      if KeywordArguments.fully_supported?
+        def method_missing(method_name, *args, **kwargs, &block)
+          @double_definition_create.call(method_name, args, kwargs, &block)
+        end
+      else
+        def method_missing(method_name, *args, &block)
+          @double_definition_create.call(method_name, args, {}, &block)
+        end
       end
 
       def __double_definition_create__
         @double_definition_create
       end
-    end    
+    end
   end
-end
+end

data/lib/rr/double_definitions/double_injections/any_instance_of.rb

@@ -3,7 +3,7 @@ module RR
     module DoubleInjections
       class AnyInstanceOf
         extend(Module.new do
-          include RR::Adapters::RRMethods
+          include RR::DSL
 
           def call(subject_class, stubbed_methods=nil, &block)
             strategy_lambda = lambda do |double_definition_create|

data/lib/rr/double_definitions/double_injections/instance.rb

@@ -3,7 +3,7 @@ module RR
     module DoubleInjections
       class Instance
         extend(Module.new do
-          include ::RR::Adapters::RRMethods
+          include ::RR::DSL
 
           def call(double_method_name, *args, &definition_eval_block)
             double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
@@ -13,4 +13,4 @@ module RR
       end
     end
   end
-end
+end

data/lib/rr/double_definitions/strategies/strategy.rb

@@ -2,7 +2,12 @@ module RR
   module DoubleDefinitions
     module Strategies
       class Strategy
-        attr_reader :double_definition_create, :definition, :method_name, :args, :handler
+        attr_reader :double_definition_create
+        attr_reader :definition
+        attr_reader :method_name
+        attr_reader :args
+        attr_reader :kwargs
+        attr_reader :handler
 
         include Space::Reader
 
@@ -10,8 +15,12 @@ module RR
           @double_definition_create = double_definition_create
         end
 
-        def call(definition, method_name, args, handler)
-          @definition, @method_name, @args, @handler = definition, method_name, args, handler
+        def call(definition, method_name, args, kwargs, handler)
+          @definition = definition
+          @method_name = method_name
+          @args = args
+          @kwargs = kwargs
+          @handler = handler
           do_call
         end
 
@@ -23,11 +32,21 @@ module RR
           raise NotImplementedError
         end
 
-        def permissive_argument
-          if args.empty?
-            definition.with_any_args
-          else
-            definition.with(*args)
+        if KeywordArguments.fully_supported?
+          def permissive_argument
+            if args.empty? and kwargs.empty?
+              definition.with_any_args
+            else
+              definition.with(*args, **kwargs)
+            end
+          end
+        else
+          def permissive_argument
+            if args.empty?
+              definition.with_any_args
+            else
+              definition.with(*args)
+            end
           end
         end
 

data/lib/rr/double_definitions/strategies/verification/mock.rb

@@ -32,8 +32,14 @@ module RR
         #   end
         class Mock < VerificationStrategy
           protected
-          def do_call
-            definition.with(*args).once
+          if KeywordArguments.fully_supported?
+            def do_call
+              definition.with(*args, **kwargs).once
+            end
+          else
+            def do_call
+              definition.with(*args).once
+            end
           end
         end
       end

data/lib/rr/double_matches.rb

@@ -15,9 +15,10 @@ module RR
       @wildcard_non_terminal_doubles_to_attempt = []
     end
 
-    def find_all_matches(args)
+    def find_all_matches(args, kwargs)
+      kwargs ||= {}
       @doubles.each do |double|
-        if double.exact_match?(*args)
+        if double.exact_match?(args, kwargs)
           matching_doubles << double
           if double.attempt?
             if double.terminal?
@@ -26,7 +27,7 @@ module RR
               exact_non_terminal_doubles_to_attempt << double
             end
           end
-        elsif double.wildcard_match?(*args)
+        elsif double.wildcard_match?(args, kwargs)
           matching_doubles << double
           if double.attempt?
             if double.terminal?

data/lib/rr/dsl.rb

@@ -0,0 +1,152 @@
+module RR
+  module DSL
+    METHODS_TO_EXCLUDE_FROM_SPYING = [
+      :methods,
+      :==,
+      :__send__,
+      :__id__,
+      :object_id,
+      :class,
+      :respond_to?,
+      :inspect,
+      :to_s,
+      :respond_to_missing?,
+      :instance_eval,
+      :instance_exec
+    ]
+
+    include DoubleDefinitions::Strategies::StrategyMethods
+
+    def mock(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.mock(subject, method_name, &definition_eval_block)
+    end
+
+    def stub(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.stub(subject, method_name, &definition_eval_block)
+    end
+
+    def dont_allow(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.dont_allow(subject, method_name, &definition_eval_block)
+    end
+
+    def proxy(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.proxy(subject, method_name, &definition_eval_block)
+    end
+
+    def strong(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.strong(subject, method_name, &definition_eval_block)
+    end
+
+    def instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.instance_of(subject, method_name, &definition_eval_block)
+    end
+
+    def any_instance_of(*args, &block)
+      RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
+    end
+
+    # Verifies all the DoubleInjection objects have met their
+    # TimesCalledExpectations.
+    def verify
+      RR::Space.instance.verify_doubles
+    end
+
+    # Resets the registered Doubles and ordered Doubles
+    def reset
+      RR::Space.instance.reset
+    end
+
+    # Returns a AnyTimesMatcher. This is meant to be passed in as an argument
+    # to Double#times.
+    #
+    #   mock(object).method_name(anything).times(any_times) {return_value}
+    def any_times
+      TimesCalledMatchers::AnyTimesMatcher.new
+    end
+
+    # Sets up an Anything wildcard ArgumentEqualityExpectation
+    # that succeeds when passed any argument.
+    #   mock(object).method_name(anything) {return_value}
+    #   object.method_name("an arbitrary value") # passes
+    def anything
+      RR::WildcardMatchers::Anything.new
+    end
+
+    # Sets up an IsA wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument of a certain type.
+    #   mock(object).method_name(is_a(String)) {return_value}
+    #   object.method_name("A String") # passes
+    def is_a(klass)
+      RR::WildcardMatchers::IsA.new(klass)
+    end
+
+    # Sets up an Numeric wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is ::Numeric.
+    #   mock(object).method_name(numeric) {return_value}
+    #   object.method_name(99) # passes
+    def numeric
+      RR::WildcardMatchers::Numeric.new
+    end
+
+    # Sets up an Boolean wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is a ::Boolean.
+    #   mock(object).method_name(boolean) {return_value}
+    #   object.method_name(false) # passes
+    def boolean
+      RR::WildcardMatchers::Boolean.new
+    end
+
+    # Sets up a DuckType wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument implements the methods.
+    #   arg = Object.new
+    #   def arg.foo; end
+    #   def arg.bar; end
+    #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
+    #   object.method_name(arg) # passes
+    def duck_type(*args)
+      RR::WildcardMatchers::DuckType.new(*args)
+    end
+
+    # Sets up a HashIncluding wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument contains at least those keys
+    # and values of the expectation.
+    #   mock(object).method_name(hash_including(:foo => 1)) {return_value}
+    #   object.method_name({:foo => 1, :bar => 2) # passes
+    def hash_including(expected_hash)
+      RR::WildcardMatchers::HashIncluding.new(expected_hash)
+    end
+
+    # Sets up a Satisfy wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument causes the expectation's
+    # proc to return true.
+    #   mock(object).method_name(satisfy {|arg| arg == :foo}) {return_value}
+    #   object.method_name(:foo) # passes
+    def satisfy(expectation_proc=nil, &block)
+      expectation_proc ||= block
+      RR::WildcardMatchers::Satisfy.new(expectation_proc)
+    end
+
+    def spy(subject)
+      subject_methods = subject.public_methods.map {|method_name| method_name.to_sym }
+      methods_to_stub = subject_methods - METHODS_TO_EXCLUDE_FROM_SPYING
+
+      methods_to_stub.each do |method|
+        stub.proxy(subject, method)
+      end
+    end
+
+    def received(subject)
+      RR::SpyVerificationProxy.new(subject)
+    end
+
+    instance_methods.each do |name|
+      alias_method "rr_#{name}", name
+    end
+  end
+end