rr 0.4.10 → 0.6.0

data/lib/rr/double_definitions/double_definition_creator_proxy.rb

@@ -0,0 +1,25 @@
+module RR
+  module DoubleDefinitions
+    class DoubleDefinitionCreatorProxy
+      def initialize(creator, &block) #:nodoc:
+        @creator = creator
+        class << self
+          instance_methods.each do |m|
+            unless m =~ /^_/ || m.to_s == 'object_id'
+              undef_method m
+            end
+          end
+
+          def method_missing(method_name, *args, &block)
+            @creator.create(method_name, *args, &block)
+          end
+        end
+        yield(self) if block_given?
+      end
+
+      def __creator__
+        @creator
+      end
+    end    
+  end
+end

data/lib/rr/double_definitions/strategies/implementation/implementation_strategy.rb

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class ImplementationStrategy < Strategy
+          class << self
+            def register_self_at_double_definition_creator(domain_name)
+              DoubleDefinitionCreator.register_implementation_strategy_class(self, domain_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/implementation/proxy.rb

@@ -0,0 +1,62 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        # This method add proxy capabilities to the Double. proxy can be called
+        # with mock or stub.
+        #
+        #   mock.proxy(controller.template).render(:partial => "my/socks")
+        #
+        #   stub.proxy(controller.template).render(:partial => "my/socks") do |html|
+        #     html.should include("My socks are wet")
+        #     html
+        #   end
+        #
+        #   mock.proxy(controller.template).render(:partial => "my/socks") do |html|
+        #     html.should include("My socks are wet")
+        #     "My new return value"
+        #   end
+        #
+        # mock.proxy also takes a block for definitions.
+        #   mock.proxy(subject) do
+        #     render(:partial => "my/socks")
+        #
+        #     render(:partial => "my/socks") do |html|
+        #       html.should include("My socks are wet")
+        #       html
+        #     end
+        #
+        #     render(:partial => "my/socks") do |html|
+        #       html.should include("My socks are wet")
+        #       html
+        #     end
+        #
+        #     render(:partial => "my/socks") do |html|
+        #       html.should include("My socks are wet")
+        #       "My new return value"
+        #     end
+        #   end
+        #
+        # Passing a block to the Double (after the method name and arguments)
+        # allows you to intercept the return value.
+        # The return value can be modified, validated, and/or overridden by
+        # passing in a block. The return value of the block will replace
+        # the actual return value.
+        #
+        #   mock.proxy(controller.template).render(:partial => "my/socks") do |html|
+        #     html.should include("My socks are wet")
+        #     "My new return value"
+        #   end        
+        class Proxy < ImplementationStrategy
+          register("proxy", :probe)
+
+          protected
+          def do_call
+            definition.implemented_by_original_method
+            definition.after_call(&handler) if handler
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/implementation/reimplementation.rb

@@ -0,0 +1,14 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class Reimplementation < ImplementationStrategy
+          protected
+          def do_call
+            reimplementation
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/scope/instance.rb

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Scope
+        class Instance < ScopeStrategy
+          protected
+          def do_call
+            double_injection = space.double_injection(subject, method_name)
+            Double.new(double_injection, definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/scope/instance_of_class.rb

@@ -0,0 +1,43 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Scope
+        # Calling instance_of will cause all instances of the passed in Class
+        # to have the Double defined.
+        #
+        # The following example mocks all User's valid? method and return false.
+        #   mock.instance_of(User).valid? {false}
+        #
+        # The following example mocks and proxies User#projects and returns the
+        # first 3 projects.
+        #   mock.instance_of(User).projects do |projects|
+        #     projects[0..2]
+        #   end        
+        class InstanceOfClass < ScopeStrategy
+          register "instance_of"
+
+          def initialize(*args)
+            super
+
+            if !double_definition_creator.no_subject? && !double_definition_creator.subject.is_a?(Class)
+              raise ArgumentError, "instance_of only accepts class objects"
+            end
+          end
+
+          protected
+          def do_call
+            class_handler = lambda do |return_value|
+              double_injection = space.double_injection(return_value, method_name)
+              Double.new(double_injection, definition)
+              return_value
+            end
+
+            instance_of_subject_creator = DoubleDefinitionCreator.new
+            instance_of_subject_creator.stub.proxy(subject)
+            instance_of_subject_creator.create(:new, &class_handler)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/scope/scope_strategy.rb

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Scope
+        class ScopeStrategy < Strategy
+          class << self
+            def register_self_at_double_definition_creator(domain_name)
+              DoubleDefinitionCreator.register_scope_strategy_class(self, domain_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      class Strategy
+        class << self
+          attr_reader :domain_name
+          def register(domain_name, *alias_method_names)
+            @domain_name = domain_name
+            register_self_at_double_definition_creator(domain_name)
+            DoubleDefinitionCreator.class_eval do
+              alias_method_names.each do |alias_method_name|
+                alias_method alias_method_name, domain_name
+              end
+            end
+            RR::Adapters::RRMethods.register_strategy_class(self, domain_name)
+            DoubleDefinition.register_strategy_class(self, domain_name)
+            RR::Adapters::RRMethods.class_eval do
+              alias_method_names.each do |alias_method_name|
+                alias_method alias_method_name, domain_name
+              end
+            end
+          end
+
+          def register_self_at_double_definition_creator
+          end
+        end
+
+        attr_reader :double_definition_creator, :definition, :method_name, :args, :handler
+        include Space::Reader
+
+        def initialize(double_definition_creator)
+          @double_definition_creator = double_definition_creator
+        end
+        
+        def call(definition, method_name, args, handler)
+          @definition, @method_name, @args, @handler = definition, method_name, args, handler
+          do_call
+        end
+
+        def name
+          self.class.domain_name
+        end
+
+        def verify_subject(subject)
+        end  
+
+        protected
+        def do_call
+          raise NotImplementedError
+        end
+
+        def permissive_argument
+          if args.empty?
+            definition.with_any_args
+          else
+            definition.with(*args)
+          end
+        end
+
+        def reimplementation
+          definition.returns(&handler)
+        end
+
+        def subject
+          definition.subject
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a dont_allow strategy.
+        # A dont_allow strategy sets the default state of the Double
+        # to expect never to be called. The Double's expectations can be
+        # changed.
+        #
+        # The following example sets the expectation that subject.method_name
+        # will never be called with arg1 and arg2.
+        #
+        #   do_not_allow(subject).method_name(arg1, arg2)
+        #
+        # dont_allow also supports a block sytnax.
+        #    dont_allow(subject) do |m|
+        #      m.method1 # Do not allow method1 with any arguments
+        #      m.method2(arg1, arg2) # Do not allow method2 with arguments arg1 and arg2
+        #      m.method3.with_no_args # Do not allow method3 with no arguments
+        #    end        
+        class DontAllow < VerificationStrategy
+          register("dont_allow", :do_not_allow, :dont_call, :do_not_call)
+
+          protected
+          def do_call
+            definition.never
+            permissive_argument
+            reimplementation
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a mock strategy. A mock strategy
+        # sets the default state of the Double to expect the method call
+        # with arguments exactly one time. The Double's expectations can be
+        # changed.
+        #
+        # This method can be chained with proxy.
+        #   mock.proxy(subject).method_name_1
+        #   or
+        #   proxy.mock(subject).method_name_1
+        #
+        # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
+        # a method with arguments to the proxy will set up expectations that
+        # the a call to the subject's method with the arguments will happen,
+        # and return the prescribed value.
+        #   mock(subject).method_name_1 {return_value_1}
+        #   mock(subject).method_name_2(arg1, arg2) {return_value_2}
+        #
+        # When passed the subject and the method_name, this method returns
+        # a mock Double with the method already set.
+        #
+        #   mock(subject, :method_name_1) {return_value_1}
+        #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+        #
+        # mock also takes a block for definitions.
+        #   mock(subject) do
+        #     method_name_1 {return_value_1}
+        #     method_name_2(arg_1, arg_2) {return_value_2}
+        #   end        
+        class Mock < VerificationStrategy
+          register "mock"
+
+          protected
+          def do_call
+            definition.with(*args).once
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a stub strategy. A stub strategy
+        # sets the default state of the Double to expect the method call
+        # with any arguments any number of times. The Double's
+        # expectations can be changed.
+        #
+        # This method can be chained with proxy.
+        #   stub.proxy(subject).method_name_1
+        #   or
+        #   proxy.stub(subject).method_name_1
+        #
+        # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
+        # a method with arguments to the proxy will set up expectations that
+        # the a call to the subject's method with the arguments will happen,
+        # and return the prescribed value.
+        #   stub(subject).method_name_1 {return_value_1}
+        #   stub(subject).method_name_2(arg_1, arg_2) {return_value_2}
+        #
+        # When passed the subject and the method_name, this method returns
+        # a stub Double with the method already set.
+        #
+        #   mock(subject, :method_name_1) {return_value_1}
+        #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+        #
+        # stub also takes a block for definitions.
+        #   stub(subject) do
+        #     method_name_1 {return_value_1}
+        #     method_name_2(arg_1, arg_2) {return_value_2}
+        #   end        
+        class Stub < VerificationStrategy
+          register "stub"
+
+          protected
+          def do_call
+            definition.any_number_of_times
+            permissive_argument
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        class VerificationStrategy < Strategy
+          class << self
+            def register_self_at_double_definition_creator(domain_name)
+              DoubleDefinitionCreator.register_verification_strategy_class(self, domain_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_injection.rb

@@ -1,16 +1,21 @@
 module RR
-  # RR::DoubleInjection is the binding of an object and a method.
+  # RR::DoubleInjection is the binding of an subject and a method.
   # A double_injection has 0 to many Double objects. Each Double
   # has Argument Expectations and Times called Expectations.
   class DoubleInjection
     MethodArguments = Struct.new(:arguments, :block)
-    attr_reader :object, :method_name, :doubles
+    attr_reader :subject, :method_name, :doubles
 
-    def initialize(object, method_name)
-      @object = object
+    def initialize(subject, method_name)
+      @subject = subject
       @method_name = method_name.to_sym
       if object_has_method?(method_name)
-        meta.__send__(:alias_method, original_method_name, method_name)
+        begin
+          meta.__send__(:alias_method, original_method_name, method_name)
+        rescue NameError => e
+          subject.send(method_name)
+          meta.__send__(:alias_method, original_method_name, method_name)
+        end
       end
       @doubles = []
     end
@@ -44,7 +49,7 @@ module RR
     end
 
     # RR::DoubleInjection#reset removes the injected dispatcher method.
-    # It binds the original method implementation on the object
+    # It binds the original method implementation on the subject
     # if one exists.
     def reset
       meta.__send__(:remove_method, placeholder_name)
@@ -57,7 +62,7 @@ module RR
     end
 
     def call_original_method(*args, &block)
-      @object.__send__(original_method_name, *args, &block)
+      @subject.__send__(original_method_name, *args, &block)
     end
 
     def object_has_original_method?
@@ -74,9 +79,10 @@ module RR
 
     def call_method(args, block)
       if double = find_double_to_attempt(args)
-        return double.call(self, *args, &block)
+        double.call(self, *args, &block)
+      else
+        double_not_found_error(*args)
       end
-      double_not_found_error(*args)
     end
 
     def find_double_to_attempt(args)
@@ -99,17 +105,17 @@ module RR
       end
 
       unless matches.matching_doubles.empty?
-        # This will raise a TimesCalledError
-        return matches.matching_doubles.first
+        return matches.matching_doubles.first # This will raise a TimesCalledError
       end
 
       return nil
     end
 
     def double_not_found_error(*args)
-      message = "On object #{object},\n"
-      message << "unexpected method invocation in the next line followed by the expected invocations\n"
+      message = "On subject #{subject},\n"
+      message << "unexpected method invocation:\n"
       message << "  #{Double.formatted_name(@method_name, args)}\n"
+      message << "expected invocations:\n"
       message << Double.list_message_part(@doubles)
       raise Errors::DoubleNotFoundError, message
     end
@@ -123,11 +129,11 @@ module RR
     end
 
     def object_has_method?(method_name)
-      @object.methods.include?(method_name.to_s) || @object.respond_to?(method_name)
+      @subject.methods.include?(method_name.to_s) || @subject.respond_to?(method_name)
     end
 
     def meta
-      (class << @object; self; end)
+      (class << @subject; self; end)
     end
   end
 end