rr 0.10.0 → 0.10.2

data/CHANGES

@@ -1,3 +1,10 @@
+0.10.2
+- RR properly proxies subjects with private methods [http://github.com/btakita/rr/issues/#issue/7]. Identified by Matthew O'Connor.
+
+0.10.1
+- Fixed issue with DoubleInjection not invoking methods that are lazily created [http://github.com/btakita/rr/issues/#issue/4]. Identified by davidlee (http://github.com/davidlee)
+- Fixed issue with mock.proxy and returns [http://github.com/btakita/rr/issues/#issue/2]. Identified by trogdoro (http://github.com/trogdoro)
+
 * 0.10.0
 - Method is no longer invoked if respond_to? returns false. This was in place to support ActiveRecord association proxies, and is no longer needed. 
 

data/README.rdoc

@@ -38,6 +38,14 @@ Currently RR implements mocks, stubs, proxies, and spies. Fakes usually require
     # config.mock_with RR::Adapters::Rspec
   end
 
+== standalone
+  extend RR::Adapters::RRMethods
+  mock(object).method_name {:return_value}
+
+  object.method_name # Returns :return_value
+
+  RR.verify # Verifies the Double expectations are satisfied
+
 == Syntax between RR and other double/mock frameworks
 === Terse Syntax
 One of the goals of RR is to make doubles more scannable.

data/Rakefile

@@ -47,3 +47,38 @@ begin
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
+RUBYFORGE_PACKAGE_NAME = "rr (Double R)"
+
+# This is hacked to get around the 3 character limitation for package names on Rubyforge.
+# http://rubyforge.org/tracker/index.php?func=detail&aid=27026&group_id=5&atid=102
+class Jeweler
+  module Commands
+    class ReleaseToRubyforge
+      def run
+        raise NoRubyForgeProjectInGemspecError unless @gemspec.rubyforge_project
+
+        @rubyforge.configure rescue nil
+
+        output.puts 'Logging in rubyforge'
+        @rubyforge.login
+
+        @rubyforge.userconfig['release_notes'] = @gemspec.description if @gemspec.description
+        @rubyforge.userconfig['preformatted'] = true
+
+        output.puts "Releasing #{@gemspec.name}-#{@version} to #{@gemspec.rubyforge_project}"
+        begin
+          @rubyforge.add_release(@gemspec.rubyforge_project, RUBYFORGE_PACKAGE_NAME, @version.to_s, @gemspec_helper.gem_path)
+        rescue StandardError => e
+          case e.message
+          when /no <group_id> configured for <#{Regexp.escape @gemspec.rubyforge_project}>/
+            raise RubyForgeProjectNotConfiguredError, @gemspec.rubyforge_project
+          when /no <package_id> configured for <#{Regexp.escape @gemspec.name}>/i
+            raise MissingRubyForgePackageError, @gemspec.name
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :minor: 10
-:patch: 0
+:patch: 2
 :major: 0

data/lib/rr/double_definitions/double_definition.rb

@@ -245,14 +245,15 @@ module RR
         #
         # Passing in an argument causes Double to return the argument.
         def returns(*args, &implementation)
-          value = args.first
           if !args.empty? && implementation
             raise ArgumentError, "returns cannot accept both an argument and a block"
           end
           if implementation
-            implemented_by implementation
+            install_method_callback implementation
           else
-            implemented_by proc {value}
+            install_method_callback(lambda do
+              return *args
+            end)
           end
           self
         end
@@ -288,7 +289,7 @@ module RR
           if implementation_is_original_method?
             after_call(&block)
           else
-            returns(&block)
+            implemented_by block
           end
         end
       end

data/lib/rr/double_injection.rb

@@ -4,6 +4,13 @@ module RR
   # has Argument Expectations and Times called Expectations.
   class DoubleInjection
     include Space::Reader
+
+    LAZY_METHOD_DEFINITIONS = [
+      (lambda do |subject|
+        subject.respond_to?(:descends_from_active_record?) && subject.descends_from_active_record?
+      end)
+    ]
+
     MethodArguments = Struct.new(:arguments, :block)
     attr_reader :subject, :method_name, :doubles, :subject_class
     
@@ -11,7 +18,10 @@ module RR
       @subject = subject
       @subject_class = subject_class
       @method_name = method_name.to_sym
-      if object_has_method?(method_name)
+      if subject_respond_to_method?(method_name)
+        if LAZY_METHOD_DEFINITIONS.any? {|definition| definition.call(subject)} && !subject.methods.include?(method_name)
+          subject.send(method_name)
+        end
         subject_class.__send__(:alias_method, original_method_alias_name, method_name)
       end
       @doubles = []
@@ -62,7 +72,7 @@ module RR
     end
 
     def object_has_original_method?
-      object_has_method?(original_method_alias_name)
+      subject_respond_to_method?(original_method_alias_name)
     end
 
     def call_method(args, block)
@@ -115,8 +125,12 @@ module RR
       "__rr__original_#{@method_name}"
     end
 
-    def object_has_method?(method_name)
-      @subject.methods.include?(method_name.to_s) || @subject.respond_to?(method_name)
+    def subject_respond_to_method?(method_name)
+      subject_has_method_defined?(method_name) || @subject.respond_to?(method_name)
+    end
+
+    def subject_has_method_defined?(method_name)
+      @subject.methods.include?(method_name.to_s) || @subject.protected_methods.include?(method_name.to_s) || @subject.private_methods.include?(method_name.to_s)
     end
   end
 end

data/spec/rr/double_injection/double_injection_bind_spec.rb

@@ -16,18 +16,44 @@ module RR
             @subject.methods.should include(method_name.to_s)
 
             subject.method(:foobar).should == original_method
-
-            @double_injection = RR::Space.double_injection(subject, method_name)
           end
 
-          it "overrides the original method with the double_injection's dispatching methods" do
-            double_injection.bind
-            subject.method(:foobar).should_not == original_method
+          context "when the existing method is public" do
+            before do
+              stub(subject, method_name).returns {:new_foobar}
+            end
+
+            it "returns the value of the Double Injection" do
+              subject.foobar.should == :new_foobar
+            end
+
+            it "overrides the original method with the double_injection's dispatching methods" do
+              subject.method(:foobar).should_not == original_method
+            end
+
+            it "stores original method in __rr__original_method_alias_name" do
+              subject.respond_to?(:__rr__original_foobar).should == true
+              subject.method(:__rr__original_foobar).should == original_method
+            end
           end
 
-          it "stores original method in __rr__original_method_alias_name" do
-            subject.respond_to?(:__rr__original_foobar).should == true
-            subject.method(:__rr__original_foobar).should == original_method
+          context "when the existing method is private" do
+            before do
+              class << subject
+                private :foobar
+              end
+              @double_injection = RR::Space.double_injection(subject, method_name)
+            end
+
+            it "overrides the original method with the double_injection's dispatching methods" do
+              double_injection.bind
+              subject.method(:foobar).should_not == original_method
+            end
+
+            it "stores original method in __rr__original_method_alias_name" do
+              subject.private_methods.should include('__rr__original_foobar')
+              subject.method(:__rr__original_foobar).should == original_method
+            end
           end
         end
 

data/spec/rr/double_injection/double_injection_dispatching_spec.rb

@@ -102,20 +102,20 @@ module RR
         end
 
         it "dispatches to Double with wildcard match" do
-          double = new_double(anything) {:return_value}
+          new_double(anything) {:return_value}
           subject.foobar(:dont_care).should == :return_value
         end
 
         it "matches to the last Double that was registered with a wildcard match" do
-          double_1 = new_double(anything) {:value_1}
-          double_2 = new_double(anything) {:value_2}
+          new_double(anything) {:value_1}
+          new_double(anything) {:value_2}
 
           subject.foobar(:dont_care).should == :value_2
         end
 
         it "matches to Double with exact match Double even when a Double with wildcard match was registered later" do
-          exact_double_registered_first = new_double(1, 2) {:exact_first}
-          wildcard_double_registered_last = new_double(anything, anything) {:wildcard_last}
+          new_double(1, 2) {:exact_first}
+          new_double(anything, anything) {:wildcard_last}
 
           subject.foobar(1, 2).should == :exact_first
         end
@@ -130,30 +130,30 @@ module RR
 
       context "when two or more Terminal Doubles with duplicate Exact Match ArgumentExpectations exists" do
         it "dispatches to Double that have an exact match" do
-          double1_with_exact_match = new_double(:exact_match) {:return_1}
+          new_double(:exact_match) {:return_1}
 
           subject.foobar(:exact_match).should == :return_1
         end
 
         it "dispatches to the first Double that have an exact match" do
-          double1_with_exact_match = new_double(:exact_match) {:return_1}
-          double2_with_exact_match = new_double(:exact_match) {:return_2}
+          new_double(:exact_match) {:return_1}
+          new_double(:exact_match) {:return_2}
 
           subject.foobar(:exact_match).should == :return_1
         end
 
         it "dispatches the second Double with an exact match
           when the first double's Times Called expectation is satisfied" do
-          double1_with_exact_match = new_double(:exact_match) {:return_1}
-          double2_with_exact_match = new_double(:exact_match) {:return_2}
+          new_double(:exact_match) {:return_1}
+          new_double(:exact_match) {:return_2}
 
           subject.foobar(:exact_match)
           subject.foobar(:exact_match).should == :return_2
         end
 
         it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
-          double1_with_exact_match = new_double(:exact_match) {:return_1}
-          double2_with_exact_match = new_double(:exact_match) {:return_2}
+          new_double(:exact_match) {:return_1}
+          new_double(:exact_match) {:return_2}
 
           subject.foobar(:exact_match)
           subject.foobar(:exact_match)
@@ -172,30 +172,30 @@ module RR
 
       context "when two or more Doubles with duplicate Wildcard Match ArgumentExpectations exists" do
         it "dispatches to Double that have a wildcard match" do
-          double_1 = new_double {:return_1}
+          new_double {:return_1}
 
           subject.foobar(:anything).should == :return_1
         end
 
         it "dispatches to the first Double that has a wildcard match" do
-          double_1 = new_double {:return_1}
-          double_2 = new_double {:return_2}
+          new_double {:return_1}
+          new_double {:return_2}
 
           subject.foobar(:anything).should == :return_1
         end
 
         it "dispatches the second Double with a wildcard match
           when the first double's Times Called expectation is satisfied" do
-          double_1 = new_double {:return_1}
-          double_2 = new_double {:return_2}
+          new_double {:return_1}
+          new_double {:return_2}
 
           subject.foobar(:anything)
           subject.foobar(:anything).should == :return_2
         end
 
         it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
-          double_1 = new_double {:return_1}
-          double_2 = new_double {:return_2}
+          new_double {:return_1}
+          new_double {:return_2}
 
           subject.foobar(:anything)
           subject.foobar(:anything)

data/spec/rr/double_injection/double_injection_spec.rb

@@ -23,14 +23,14 @@ module RR
       end
 
       context "when method_name is a string" do
-        send("sets up object and method_name")
-
         before do
           @subject = Object.new
           @method_name = 'foobar'
           subject.methods.should_not include(method_name)
           @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
         end
+
+        send("sets up object and method_name")
       end
 
       context "when method does not exist on object" do
@@ -40,14 +40,30 @@ module RR
           subject.methods.should_not include(method_name.to_s)
         end
 
-        context "and invoking the method for the first time does not add the method" do
+        context "when the subject descends from active record" do
           before do
+            def subject.descends_from_active_record?
+              true
+            end
+            def subject.respond_to?(name)
+              return true if name == :foobar
+              super
+            end
+            def subject.method_missing(name, *args, &block)
+              if name == :foobar
+                def self.foobar
+                end
+              else
+                super
+              end
+            end
             @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
           end
+          
           send("sets up object and method_name")
 
-          example "object does not have original method" do
-            double_injection.object_has_original_method?.should be_false
+          example "object has the original method" do
+            double_injection.object_has_original_method?.should be_true
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.10.0
+  version: 0.10.2
 platform: ruby
 authors: 
 - Brian Takita
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-01 00:00:00 -07:00
+date: 2009-08-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -158,6 +158,8 @@ files:
 - spec/test_unit_spec_suite.rb
 has_rdoc: true
 homepage: http://pivotallabs.com
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -181,9 +183,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: pivotalrb
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: RR (Double Ruby) is a double framework that features a rich selection of double techniques and a terse syntax. http://xunitpatterns.com/Test%20Double.html
 test_files: 
 - spec/spy_verification_spec.rb