rr 0.4.10 → 0.6.0

data/lib/rr/expectations/argument_equality_expectation.rb

@@ -12,6 +12,7 @@ module RR
         arguments.each_with_index do |arg, index|
           return false unless equality_match(@expected_arguments[index], arg)
         end
+        true
       end
 
       def wildcard_match?(*arguments)
@@ -24,7 +25,7 @@ module RR
             return false unless equality_match(expected_argument, arg)
           end
         end
-        return true
+        true
       end
 
       def ==(other)

data/lib/rr/space.rb

@@ -1,5 +1,5 @@
 module RR
-  # RR::Space.instance is the global state object for the RR framework.
+  # RR::Space.instance is the global state subject for the RR framework.
   class Space
     module Reader
       def space
@@ -28,22 +28,22 @@ module RR
     end
 
     # Reuses or creates, if none exists, a DoubleInjection for the passed
-    # in object and method_name.
+    # in subject and method_name.
     # When a DoubleInjection is created, it binds the dispatcher to the
-    # object.
-    def double_injection(object, method_name)
-      double_injection = @double_injections[object][method_name.to_sym]
+    # subject.
+    def double_injection(subject, method_name)
+      double_injection = @double_injections[subject][method_name.to_sym]
       return double_injection if double_injection
 
-      double_injection = DoubleInjection.new(object, method_name.to_sym)
-      @double_injections[object][method_name.to_sym] = double_injection
+      double_injection = DoubleInjection.new(subject, method_name.to_sym)
+      @double_injections[subject][method_name.to_sym] = double_injection
       double_injection.bind
       double_injection
     end
 
     # Registers the ordered Double to be verified.
     def register_ordered_double(double)
-      @ordered_doubles << double
+      @ordered_doubles << double unless ordered_doubles.include?(double)
     end
 
     # Verifies that the passed in ordered Double is being called
@@ -65,10 +65,11 @@ module RR
 
     # Verifies all the DoubleInjection objects have met their
     # TimesCalledExpectations.
-    def verify_doubles
-      @double_injections.each do |object, method_double_map|
-        method_double_map.keys.each do |method_name|
-          verify_double(object, method_name)
+    def verify_doubles(*objects)
+      objects = @double_injections.keys if objects.empty?
+      objects.each do |subject|
+        @double_injections[subject].keys.each do |method_name|
+          verify_double(subject, method_name)
         end
       end
     end
@@ -80,17 +81,17 @@ module RR
       reset_double_injections
     end
 
-    # Verifies the DoubleInjection for the passed in object and method_name.
-    def verify_double(object, method_name)
-      @double_injections[object][method_name].verify
+    # Verifies the DoubleInjection for the passed in subject and method_name.
+    def verify_double(subject, method_name)
+      @double_injections[subject][method_name].verify
     ensure
-      reset_double object, method_name
+      reset_double subject, method_name
     end
 
-    # Resets the DoubleInjection for the passed in object and method_name.
-    def reset_double(object, method_name)
-      double_injection = @double_injections[object].delete(method_name)
-      @double_injections.delete(object) if @double_injections[object].empty?
+    # Resets the DoubleInjection for the passed in subject and method_name.
+    def reset_double(subject, method_name)
+      double_injection = @double_injections[subject].delete(method_name)
+      @double_injections.delete(subject) if @double_injections[subject].empty?
       double_injection.reset
     end
 
@@ -102,9 +103,9 @@ module RR
 
     # Resets the registered Doubles for the next test run.
     def reset_double_injections
-      @double_injections.each do |object, method_double_map|
+      @double_injections.each do |subject, method_double_map|
         method_double_map.keys.each do |method_name|
-          reset_double(object, method_name)
+          reset_double(subject, method_name)
         end
       end
     end    

data/lib/rr/wildcard_matchers/hash_including.rb

@@ -0,0 +1,29 @@
+module RR
+  module WildcardMatchers
+    class HashIncluding
+      attr_reader :expected_hash
+
+      def initialize(expected_hash)
+        @expected_hash = expected_hash.clone
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        expected_hash.each_pair do |key, value|
+          return false unless other.has_key?(key) && other[key] == expected_hash[key]
+        end
+        return true
+      end
+
+      def inspect
+        "hash_including(#{expected_hash.inspect})"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.expected_hash == other.expected_hash
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/lib/rr/wildcard_matchers/satisfy.rb

@@ -0,0 +1,26 @@
+module RR
+  module WildcardMatchers
+    class Satisfy
+      attr_reader :expectation_proc
+
+      def initialize(expectation_proc)
+        @expectation_proc = expectation_proc
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        !!expectation_proc.call(other)
+      end
+
+      def inspect
+        "satisfy {block}"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.expectation_proc == other.expectation_proc
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/spec/high_level_spec.rb

@@ -1,12 +1,12 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
 
 class HighLevelSpec
 end
 
 describe "RR" do
+  attr_reader :subject
   before(:each) do
-    @obj = Object.new
+    @subject = Object.new
     extend RR::Adapters::RRMethods
   end
 
@@ -16,31 +16,78 @@ describe "RR" do
 
   describe "RR mock:" do
     it "mocks via inline call" do
-      mock(@obj).to_s {"a value"}
-      @obj.to_s.should == "a value"
-      lambda {@obj.to_s}.should raise_error(RR::Errors::TimesCalledError)
+      mock(subject).to_s {"a value"}
+      subject.to_s.should == "a value"
+      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
     end
 
     it "allows ordering" do
-      mock(@obj).to_s {"value 1"}.ordered
-      mock(@obj).to_s {"value 2"}.twice.ordered
-      @obj.to_s.should == "value 1"
-      @obj.to_s.should == "value 2"
-      @obj.to_s.should == "value 2"
-      lambda {@obj.to_s}.should raise_error(RR::Errors::TimesCalledError)
+      mock(subject).to_s {"value 1"}.ordered
+      mock(subject).to_s {"value 2"}.twice
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+      subject.to_s.should == "value 2"
+      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+    end
+    
+    it 'allows terse chaining' do
+      mock(subject).first(1) {mock(Object.new).second(2) {mock(Object.new).third(3) {4}}}
+      subject.first(1).second(2).third(3).should == 4
+
+      mock(subject).first(1) {mock!.second(2) {mock!.third(3) {4}}}
+      subject.first(1).second(2).third(3).should == 4
+      
+      mock(subject).first(1).mock!.second(2).mock!.third(3) {4}
+      subject.first(1).second(2).third(3).should == 4
+    end
+
+    it 'allows chaining with proxy' do
+      find_return_value = Object.new
+      def find_return_value.child
+        :the_child
+      end
+      (class << subject; self; end).class_eval do
+        define_method(:find) do |id|
+          id == '1' ? find_return_value : raise(ArgumentError)
+        end
+      end
+
+      mock.proxy(subject).find('1').mock.proxy!.child
+      subject.find('1').child.should == :the_child
+    end
+    
+    it 'allows branched chaining' do
+      mock(subject).first do
+        mock! do |expect|
+          expect.branch1 {mock!.branch11 {11}}
+          expect.branch2 {mock!.branch22 {22}}
+        end
+      end
+      o = subject.first
+      o.branch1.branch11.should == 11
+      o.branch2.branch22.should == 22
+    end
+    
+    it 'allows chained ordering' do
+      mock(subject).to_s {"value 1"}.then.to_s {"value 2"}.twice.then.to_s {"value 3"}.once
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+      subject.to_s.should == "value 2"
+      subject.to_s.should == "value 3"
+      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
     end
 
     it "mocks via block" do
-      mock @obj do |c|
+      mock subject do |c|
         c.to_s {"a value"}
         c.to_sym {:crazy}
       end
-      @obj.to_s.should == "a value"
-      @obj.to_sym.should == :crazy
+      subject.to_s.should == "a value"
+      subject.to_sym.should == :crazy
     end
 
     it "has wildcard matchers" do
-      mock(@obj).foobar(
+      mock(subject).foobar(
         is_a(String),
         anything,
         numeric,
@@ -48,7 +95,7 @@ describe "RR" do
         duck_type(:to_s),
         /abc/
       ) {"value 1"}.twice
-      @obj.foobar(
+      subject.foobar(
         'hello',
         Object.new,
         99,
@@ -57,116 +104,116 @@ describe "RR" do
         "Tabcola"
       ).should == "value 1"
       lambda do
-        @obj.foobar(:failure)
+        subject.foobar(:failure)
       end.should raise_error( RR::Errors::DoubleNotFoundError )
     end
 
     it "mocks methods without letters" do
-      mock(@obj) == 55
+      mock(subject) == 55
 
-      @obj == 55
+      subject == 55
       lambda do
-        @obj == 99
+        subject == 99
       end.should raise_error(RR::Errors::DoubleNotFoundError)
     end
   end
 
   describe "RR proxy:" do
     it "proxies via inline call" do
-      expected_to_s_value = @obj.to_s
-      mock.proxy(@obj).to_s
-      @obj.to_s.should == expected_to_s_value
-      lambda {@obj.to_s}.should raise_error
+      expected_to_s_value = subject.to_s
+      mock.proxy(subject).to_s
+      subject.to_s.should == expected_to_s_value
+      lambda {subject.to_s}.should raise_error
     end
 
     it "proxy allows ordering" do
-      def @obj.to_s(arg)
+      def subject.to_s(arg)
         "Original to_s with arg #{arg}"
       end
-      mock.proxy(@obj).to_s(:foo).ordered
-      mock.proxy(@obj).to_s(:bar).twice.ordered
+      mock.proxy(subject).to_s(:foo).ordered
+      mock.proxy(subject).to_s(:bar).twice.ordered
 
-      @obj.to_s(:foo).should == "Original to_s with arg foo"
-      @obj.to_s(:bar).should == "Original to_s with arg bar"
-      @obj.to_s(:bar).should == "Original to_s with arg bar"
-      lambda {@obj.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
+      subject.to_s(:foo).should == "Original to_s with arg foo"
+      subject.to_s(:bar).should == "Original to_s with arg bar"
+      subject.to_s(:bar).should == "Original to_s with arg bar"
+      lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
     end
 
     it "proxy allows ordering" do
-      def @obj.to_s(arg)
+      def subject.to_s(arg)
         "Original to_s with arg #{arg}"
       end
-      mock.proxy(@obj).to_s(:foo).ordered
-      mock.proxy(@obj).to_s(:bar).twice.ordered
+      mock.proxy(subject).to_s(:foo).ordered
+      mock.proxy(subject).to_s(:bar).twice.ordered
 
-      @obj.to_s(:foo).should == "Original to_s with arg foo"
-      @obj.to_s(:bar).should == "Original to_s with arg bar"
-      @obj.to_s(:bar).should == "Original to_s with arg bar"
-      lambda {@obj.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
+      subject.to_s(:foo).should == "Original to_s with arg foo"
+      subject.to_s(:bar).should == "Original to_s with arg bar"
+      subject.to_s(:bar).should == "Original to_s with arg bar"
+      lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
     end
 
     it "proxies via block" do
-      def @obj.foobar_1(*args)
+      def subject.foobar_1(*args)
         :original_value_1
       end
 
-      def @obj.foobar_2
+      def subject.foobar_2
         :original_value_2
       end
 
-      mock.proxy @obj do |c|
+      mock.proxy subject do |c|
         c.foobar_1(1)
         c.foobar_2
       end
-      @obj.foobar_1(1).should == :original_value_1
-      lambda {@obj.foobar_1(:blah)}.should raise_error
+      subject.foobar_1(1).should == :original_value_1
+      lambda {subject.foobar_1(:blah)}.should raise_error
 
-      @obj.foobar_2.should == :original_value_2
-      lambda {@obj.foobar_2(:blah)}.should raise_error
+      subject.foobar_2.should == :original_value_2
+      lambda {subject.foobar_2(:blah)}.should raise_error
     end
 
     it "proxies via block" do
-      def @obj.foobar_1(*args)
+      def subject.foobar_1(*args)
         :original_value_1
       end
 
-      def @obj.foobar_2
+      def subject.foobar_2
         :original_value_2
       end
 
-      mock.proxy @obj do |c|
+      mock.proxy subject do |c|
         c.foobar_1(1)
         c.foobar_2
       end
-      @obj.foobar_1(1).should == :original_value_1
-      lambda {@obj.foobar_1(:blah)}.should raise_error
+      subject.foobar_1(1).should == :original_value_1
+      lambda {subject.foobar_1(:blah)}.should raise_error
 
-      @obj.foobar_2.should == :original_value_2
-      lambda {@obj.foobar_2(:blah)}.should raise_error
+      subject.foobar_2.should == :original_value_2
+      lambda {subject.foobar_2(:blah)}.should raise_error
     end
   end
 
   describe "RR stub:" do
     it "stubs via inline call" do
-      stub(@obj).to_s {"a value"}
-      @obj.to_s.should == "a value"
+      stub(subject).to_s {"a value"}
+      subject.to_s.should == "a value"
     end
 
     it "allows ordering" do
-      stub(@obj).to_s {"value 1"}.once.ordered
-      stub(@obj).to_s {"value 2"}.once.ordered
+      stub(subject).to_s {"value 1"}.once.ordered
+      stub(subject).to_s {"value 2"}.once.ordered
 
-      @obj.to_s.should == "value 1"
-      @obj.to_s.should == "value 2"
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
     end
 
     it "stubs via block" do
-      stub @obj do |d|
+      stub subject do |d|
         d.to_s {"a value"}
         d.to_sym {:crazy}
       end
-      @obj.to_s.should == "a value"
-      @obj.to_sym.should == :crazy
+      subject.to_s.should == "a value"
+      subject.to_sym.should == :crazy
     end
 
     it "stubs instance_of" do
@@ -177,8 +224,8 @@ describe "RR" do
     end
 
     it "stubs methods without letters" do
-      stub(@obj).__send__(:==) {:equality}
-      (@obj == 55).should == :equality
+      stub(subject).__send__(:==) {:equality}
+      (subject == 55).should == :equality
     end
   end
 end