rr 0.10.11 → 1.0.0

data/CHANGES

@@ -1,3 +1,8 @@
+1.0.0
+- Added any_instance_of (aliased by all_instances_of), which binds methods directly to the class (instead of the eigenclass).
+- Subclasses of a injected class do not have their methods overridden.
+- any_instance_of and new_instance_of now have a block syntax
+
 0.10.11
 - Added RR.blank_slate_whitelist
 - Fixed class_eval method redefinition warning in jruby

data/Gemfile

@@ -0,0 +1,6 @@
+group :test do
+  gem "rspec", "1.3.0"
+  gem "session", "2.4.0"
+  gem "diff-lcs", "1.1.2"
+  gem "ruby-debug", "0.10.3"
+end

data/README.rdoc

@@ -213,9 +213,33 @@ renders the partial.
     html
   end
 
-=== instance_of
-Put double scenarios on instances of a Class.
+=== any_instance_of
+Allows stubs to be added to all instances of a class. It works by binding to methods from the class itself, rather than the eigenclass.
+This allows all instances (excluding instances with the method redefined in the eigenclass) to get the change.
 
+Due to Ruby runtime limitations, mocks will not work as expected. It's not obviously feasible (without an ObjectSpace lookup) to support all of RR's methods (such as mocking).
+ObjectSpace is not readily supported in jRuby, since it causes general slowness in the intreperter.
+I'm of the opinion that test speed is more important than having mocks on all instances of a class.
+If there is another solution, I'd be willing to add it.
+
+  any_instance_of(User) do |u|
+    stub(u).valid? {false}
+  end
+  # or
+  any_instance_of(User, :valid? => false)
+  # or
+  any_instance_of(User, :valid? => lambda {false})
+
+=== new_instance_of
+Stubs the new method of the class and allows doubles to be bound to new instances.
+
+Mocks can be used, because new instances are deterministically bound.
+
+  new_instance_of(User) do |u|
+    mock(u).valid? {false}
+  end
+
+  # Deprecated syntax
   mock.instance_of(User).valid? {false}
 
 === Spies
@@ -338,7 +362,9 @@ If you have directly contributed to RR and I missed you in this list, please let
 * Dave Myron for a bug report
 * David Chelimsky for encouragement to make the RR framework, for developing the Rspec mock framework, syntax ideas, and patches
 * Daniel Sudol for identifing performance issues with RR
+* Dmitry Ratnikov for patches
 * Felix Morio for pairing with me
+* Gabriel Horner for patches
 * Gerard Meszaros for his excellent book "xUnit Test Patterns"
 * James Mead for developing Mocha
 * Jeff Whitmire for documentation suggestions

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :build: 
-:minor: 10
-:patch: 11
-:major: 0
+:minor: 0
+:patch: 0
+:major: 1

data/lib/rr.rb

@@ -1,5 +1,4 @@
 dir = File.dirname(__FILE__)
-require 'rubygems'
 require 'forwardable'
 
 require "#{dir}/rr/blank_slate"
@@ -17,6 +16,27 @@ require "#{dir}/rr/errors/spy_verification_errors/double_injection_not_found_err
 require "#{dir}/rr/errors/spy_verification_errors/invocation_count_error"
 
 require "#{dir}/rr/space"
+
+require "#{dir}/rr/double_definitions/strategies/strategy"
+require "#{dir}/rr/double_definitions/strategies/strategy_methods"
+require "#{dir}/rr/double_definitions/strategies/verification/verification_strategy"
+require "#{dir}/rr/double_definitions/strategies/verification/mock"
+require "#{dir}/rr/double_definitions/strategies/verification/stub"
+require "#{dir}/rr/double_definitions/strategies/verification/dont_allow"
+require "#{dir}/rr/double_definitions/strategies/implementation/implementation_strategy"
+require "#{dir}/rr/double_definitions/strategies/implementation/reimplementation"
+require "#{dir}/rr/double_definitions/strategies/implementation/strongly_typed_reimplementation"
+require "#{dir}/rr/double_definitions/strategies/implementation/proxy"
+require "#{dir}/rr/double_definitions/strategies/double_injection/double_injection_strategy"
+require "#{dir}/rr/double_definitions/strategies/double_injection/instance"
+require "#{dir}/rr/double_definitions/strategies/double_injection/any_instance_of"
+require "#{dir}/rr/double_definitions/strategies/double_injection/new_instance_of"
+require "#{dir}/rr/adapters/rr_methods"
+require "#{dir}/rr/double_definitions/double_injections/instance"
+require "#{dir}/rr/double_definitions/double_injections/any_instance_of"
+require "#{dir}/rr/double_definitions/double_injections/new_instance_of"
+require "#{dir}/rr/double_definitions/double_definition"
+
 require "#{dir}/rr/injections/injection"
 require "#{dir}/rr/injections/double_injection"
 require "#{dir}/rr/injections/method_missing_injection"
@@ -27,26 +47,13 @@ require "#{dir}/rr/method_dispatches/method_missing_dispatch"
 require "#{dir}/rr/hash_with_object_id_key"
 require "#{dir}/rr/recorded_calls"
 require "#{dir}/rr/proc_from_block"
+require "#{dir}/rr/class_instance_method_defined"
 
 require "#{dir}/rr/double_definitions/double_definition_create_blank_slate"
 require "#{dir}/rr/double_definitions/double_definition_create"
 require "#{dir}/rr/double_definitions/child_double_definition_create"
-require "#{dir}/rr/adapters/rr_methods"
 
 require "#{dir}/rr/double"
-require "#{dir}/rr/double_definitions/double_definition"
-require "#{dir}/rr/double_definitions/strategies/strategy"
-require "#{dir}/rr/double_definitions/strategies/verification/verification_strategy"
-require "#{dir}/rr/double_definitions/strategies/verification/mock"
-require "#{dir}/rr/double_definitions/strategies/verification/stub"
-require "#{dir}/rr/double_definitions/strategies/verification/dont_allow"
-require "#{dir}/rr/double_definitions/strategies/implementation/implementation_strategy"
-require "#{dir}/rr/double_definitions/strategies/implementation/reimplementation"
-require "#{dir}/rr/double_definitions/strategies/implementation/strongly_typed_reimplementation"
-require "#{dir}/rr/double_definitions/strategies/implementation/proxy"
-require "#{dir}/rr/double_definitions/strategies/scope/scope_strategy"
-require "#{dir}/rr/double_definitions/strategies/scope/instance"
-require "#{dir}/rr/double_definitions/strategies/scope/instance_of_class"
 require "#{dir}/rr/double_matches"
 
 require "#{dir}/rr/expectations/argument_equality_expectation"
@@ -84,12 +91,11 @@ module RR
   class << self
     include Adapters::RRMethods
     (RR::Space.instance_methods - Object.instance_methods).each do |method_name|
-      returns_method = <<-METHOD
+      class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
         def #{method_name}(*args, &block)
           RR::Space.instance.__send__(:#{method_name}, *args, &block)
         end
       METHOD
-      class_eval(returns_method, __FILE__, __LINE__ - 4)
     end
   end
 end

data/lib/rr/adapters/rr_methods.rb

@@ -1,22 +1,40 @@
 module RR
   module Adapters
     module RRMethods
-      class << self
-        def register_strategy_class(strategy_class, method_name)
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-            double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-            double_definition_create.#{method_name}(subject, method_name, &definition_eval_block)
-          end
-          CLASS
-
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}!(method_name=nil, &definition_eval_block)
-            double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-            double_definition_create.#{method_name}!(method_name, &definition_eval_block)
-          end
-          CLASS
-        end
+      include ::RR::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 any_instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+        double_definition_create.any_instance_of(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
 
       # Verifies all the DoubleInjection objects have met their
@@ -102,7 +120,7 @@ module RR
 
       def spy(subject)
         methods_to_stub = subject.public_methods.map {|method_name| method_name.to_sym} -
-          [:methods, :==, :__send__, :__id__, :object_id]
+          [:methods, :==, :__send__, :__id__, :object_id, :class]
         methods_to_stub.each do |method|
           stub.proxy(subject, method)
         end
@@ -112,6 +130,14 @@ module RR
         RR::SpyVerificationProxy.new(subject)
       end
 
+      def new_instance_of(*args, &block)
+        RR::DoubleDefinitions::DoubleInjections::NewInstanceOf.call(*args, &block)
+      end
+
+      def any_instance_of(*args, &block)
+        RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
+      end
+
       instance_methods.each do |name|
         alias_method "rr_#{name}", name
       end

data/lib/rr/blank_slate.rb

@@ -1,6 +1,6 @@
 module RR
   module BlankSlate
-    class << self
+    extend(Module.new do
       def call(klass)
         klass.instance_eval do
           instance_methods.each do |unformatted_method_name|
@@ -12,6 +12,6 @@ module RR
           end
         end
       end
-    end
+    end)
   end
 end

data/lib/rr/class_instance_method_defined.rb

@@ -0,0 +1,9 @@
+module RR
+  module ClassInstanceMethodDefined
+    def self.call(klass, instance_method, include_super=true)
+      klass.instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym} ||
+        klass.protected_instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym} ||
+        klass.private_instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym}
+    end
+  end
+end

data/lib/rr/double.rb

@@ -3,7 +3,7 @@ module RR
   # It has the ArgumentEqualityExpectation, TimesCalledExpectation,
   # and the implementation.
   class Double
-    class << self
+    extend(Module.new do
       def formatted_name(method_name, args)
         formatted_errors = args.collect {|arg| arg.inspect}.join(', ')
         "#{method_name}(#{formatted_errors})"
@@ -14,7 +14,7 @@ module RR
           "- #{formatted_name(double.method_name, double.expected_arguments)}"
         end.join("\n")
       end
-    end
+    end)
 
     attr_reader :times_called, :double_injection, :definition, :times_called_expectation
     include Space::Reader

data/lib/rr/double_definitions/double_definition.rb

@@ -1,22 +1,6 @@
 module RR
   module DoubleDefinitions
     class DoubleDefinition #:nodoc:
-      class << self
-        def register_strategy_class(strategy_class, method_name)
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-            ChildDoubleDefinitionCreate.new(self).#{method_name}(subject, method_name, &definition_eval_block)
-          end
-          CLASS
-
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}!(method_name=nil, &definition_eval_block)
-            ChildDoubleDefinitionCreate.new(self).#{method_name}!(method_name, &definition_eval_block)
-          end
-          CLASS
-        end
-      end
-
       ORIGINAL_METHOD = Object.new
       attr_accessor(
         :argument_expectation,
@@ -349,6 +333,35 @@ module RR
         end
       end
       include StateQueryMethods
+      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
+
+      def mock(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        ChildDoubleDefinitionCreate.new(self).mock(subject, method_name, &definition_eval_block)
+      end
+
+      def stub(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        ChildDoubleDefinitionCreate.new(self).stub(subject, method_name, &definition_eval_block)
+      end
+
+      def dont_allow(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        ChildDoubleDefinitionCreate.new(self).dont_allow(subject, method_name, &definition_eval_block)
+      end
+
+      def proxy(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        ChildDoubleDefinitionCreate.new(self).proxy(subject, method_name, &definition_eval_block)
+      end
+
+      def strong(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        ChildDoubleDefinitionCreate.new(self).strong(subject, method_name, &definition_eval_block)
+      end
+
+      def any_instance_of(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        ChildDoubleDefinitionCreate.new(self).any_instance_of(subject, method_name, &definition_eval_block)
+      end
+
+      def instance_of(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        ChildDoubleDefinitionCreate.new(self).instance_of(subject, method_name, &definition_eval_block)
+      end
     end
   end
 end

data/lib/rr/double_definitions/double_definition_create.rb

@@ -1,82 +1,51 @@
 module RR
   module DoubleDefinitions
     class DoubleDefinitionCreate # :nodoc
-      class << self
-        def register_verification_strategy_class(strategy_class, strategy_method_name)
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{strategy_method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-            self.add_verification_strategy(#{strategy_class.name}, subject, method_name, &definition_eval_block)
+      extend(Module.new do
+        def default_double_injection_strategy
+          @default_double_injection_strategy ||= lambda do |double_injection_create|
+            Strategies::DoubleInjection::Instance.new(double_injection_create)
           end
-          CLASS
-
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{strategy_method_name}!(method_name=nil, &definition_eval_block)
-            #{strategy_method_name}(Object.new, method_name, &definition_eval_block)
-          end
-          CLASS
         end
-        
-        def register_implementation_strategy_class(strategy_class, strategy_method_name)
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{strategy_method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-            self.add_implementation_strategy(#{strategy_class.name}, subject, method_name, &definition_eval_block)
-          end
-          CLASS
 
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{strategy_method_name}!(method_name=nil, &definition_eval_block)
-            #{strategy_method_name}(Object.new, method_name, &definition_eval_block)
+        def set_default_double_injection_strategy(strategy_lambda)
+          original_strategy_lambda = default_double_injection_strategy
+          begin
+            @default_double_injection_strategy = strategy_lambda
+            yield
+          ensure
+            @default_double_injection_strategy = original_strategy_lambda
           end
-          CLASS
         end
+      end)
 
-        def register_scope_strategy_class(strategy_class, strategy_method_name)
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{strategy_method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-            self.add_scope_strategy(#{strategy_class.name}, subject, method_name, &definition_eval_block)
-          end
-          CLASS
-
-          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{strategy_method_name}!(method_name=nil, &definition_eval_block)
-            #{strategy_method_name}(Object.new, method_name, &definition_eval_block)
-          end
-          CLASS
-        end
-      end
-
-      attr_reader :subject, 
-                  :verification_strategy,
-                  :implementation_strategy, 
-                  :scope_strategy
+      attr_reader :subject, :verification_strategy, :implementation_strategy, :double_injection_strategy
       NO_SUBJECT = Object.new
 
       include Space::Reader
 
       def initialize
-        @verification_strategy = nil
+        @verification_strategy = Strategies::Verification::Stub.new(self)
         @implementation_strategy = Strategies::Implementation::Reimplementation.new(self)
-        @scope_strategy = Strategies::Scope::Instance.new(self)
+        @double_injection_strategy = self.class.default_double_injection_strategy.call(self)
       end
 
       def call(method_name, *args, &handler)
-        raise DoubleDefinitionCreateError if no_subject?
         definition = DoubleDefinition.new(self)
-        verification_strategy || no_strategy_error
         verification_strategy.call(definition, method_name, args, handler)
         implementation_strategy.call(definition, method_name, args, handler)
-        scope_strategy.call(definition, method_name, args, handler)
+        double_injection_strategy.call(definition, method_name, args, handler)
         definition
       end
-      
+
       def root_subject
         subject
       end
-      
+
       def method_name
         @verification_strategy.method_name
       end
-      
+
       module StrategySetupMethods
         def no_subject?
           subject.__id__ === NO_SUBJECT.__id__
@@ -95,9 +64,9 @@ module RR
           end
         end
 
-        def add_scope_strategy(scope_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        def add_double_injection_strategy(double_injection_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
           add_strategy(subject, method_name, definition_eval_block) do
-            self.scope_strategy = scope_strategy_class.new(self)
+            self.double_injection_strategy = double_injection_strategy_class.new(self)
           end
         end
 
@@ -119,56 +88,53 @@ module RR
         end
 
         def verification_strategy=(verification_strategy)
-          verify_no_verification_strategy
-          verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
           @verification_strategy = verification_strategy
           verification_strategy
         end
 
         def implementation_strategy=(implementation_strategy)
-          verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
           @implementation_strategy = implementation_strategy
         end
 
-        def scope_strategy=(scope_strategy)
-          verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
-          @scope_strategy = scope_strategy
+        def double_injection_strategy=(double_injection_strategy)
+          @double_injection_strategy = double_injection_strategy
         end
+      end
+      include StrategySetupMethods
 
-        def verify_no_verification_strategy
-          strategy_already_defined_error if verification_strategy
-        end
+      class DoubleDefinitionCreateError < Errors::RRError
+      end
 
-        def strategy_already_defined_error
-          raise(
-            Errors::DoubleDefinitionError,
-            "This Double already has a #{verification_strategy.name} strategy"
-          )
-        end
+      # Verification Strategies
+      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
+      def mock(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::Mock, subject, method_name, &definition_eval_block)
+      end
 
-        def verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
-          proxy_when_dont_allow_error if
-            verification_strategy.is_a?(Strategies::Verification::DontAllow) &&
-            implementation_strategy.is_a?(Strategies::Implementation::Proxy)
-        end
+      def stub(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::Stub, subject, method_name, &definition_eval_block)
+      end
 
-        def proxy_when_dont_allow_error
-          raise(
-            Errors::DoubleDefinitionError,
-            "Doubles cannot be proxied when using dont_allow strategy"
-          )
-        end
+      def dont_allow(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::DontAllow, subject, method_name, &definition_eval_block)
+      end
 
-        def no_strategy_error
-          raise(
-            Errors::DoubleDefinitionError,
-            "This Double has no strategy"
-          )
-        end
+      # Implementation Strategies
+      def proxy(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_implementation_strategy(::RR::DoubleDefinitions::Strategies::Implementation::Proxy, subject, method_name, &definition_eval_block)
       end
-      include StrategySetupMethods
 
-      class DoubleDefinitionCreateError < Errors::RRError
+      def strong(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_implementation_strategy(::RR::DoubleDefinitions::Strategies::Implementation::StronglyTypedReimplementation, subject, method_name, &definition_eval_block)
+      end
+
+      # DoubleInjection Strategies
+      def any_instance_of(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_double_injection_strategy(::RR::DoubleDefinitions::Strategies::DoubleInjection::AnyInstanceOf, subject, method_name, &definition_eval_block)
+      end
+
+      def instance_of(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_double_injection_strategy(::RR::DoubleDefinitions::Strategies::DoubleInjection::NewInstanceOf, subject, method_name, &definition_eval_block)
       end
     end
   end