rr 0.6.0 → 0.7.0

data/spec/rr/errors/rr_error_spec.rb

@@ -2,63 +2,65 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module Errors
-    describe RRError, "#backtrace" do
-      before do
-        @original_trim_backtrace = RR.trim_backtrace
-      end
-      after do
-        RR.trim_backtrace = @original_trim_backtrace
-      end
+    describe RRError do
+      describe "#backtrace" do
+        before do
+          @original_trim_backtrace = RR.trim_backtrace
+        end
+        after do
+          RR.trim_backtrace = @original_trim_backtrace
+        end
+
+        it "does not include the rr library files when trim_backtrace is true" do
+          RR.trim_backtrace = true
 
-      it "does not include the rr library files when trim_backtrace is true" do
-        RR.trim_backtrace = true
+          error = nil
+          begin
+            obj = Object.new
+            mock(obj).foobar
+            RR.verify_double(obj, :foobar)
+          rescue RRError=> e
+            error = e
+          end
+          backtrace = error.backtrace.join("\n")
 
-        error = nil
-        begin
-          obj = Object.new
-          mock(obj).foobar
-          RR.verify_double(obj, :foobar)
-        rescue RRError=> e
-          error = e
+          backtrace.should_not include("lib/rr")
         end
-        backtrace = error.backtrace.join("\n")
 
-        backtrace.should_not include("lib/rr")
-      end
+        it "includes the rr library files when trim_backtrace is false" do
+          RR.trim_backtrace = false
 
-      it "includes the rr library files when trim_backtrace is false" do
-        RR.trim_backtrace = false
+          error = nil
+          begin
+            obj = Object.new
+            mock(obj).foobar
+            RR.verify_double(obj, :foobar)
+          rescue RRError=> e
+            error = e
+          end
+          backtrace = error.backtrace.join("\n")
 
-        error = nil
-        begin
-          obj = Object.new
-          mock(obj).foobar
-          RR.verify_double(obj, :foobar)
-        rescue RRError=> e
-          error = e
+          backtrace.should include("lib/rr")
         end
-        backtrace = error.backtrace.join("\n")
-
-        backtrace.should include("lib/rr")
-      end
 
-      it "returns custom backtrace when backtrace is set" do
-        error = RRError.new
-        custom_backtrace = caller
-        error.backtrace = custom_backtrace
-        error.backtrace.should == custom_backtrace
-      end
+        it "returns custom backtrace when backtrace is set" do
+          error = RRError.new
+          custom_backtrace = caller
+          error.backtrace = custom_backtrace
+          error.backtrace.should == custom_backtrace
+        end
 
-      it "returns normal backtrace when backtrace is not set" do
-        error = nil
-        expected_line = __LINE__ + 2
-        begin
-          raise RRError
-        rescue RRError => e
-          error = e
+        it "returns normal backtrace when backtrace is not set" do
+          error = nil
+          expected_line = __LINE__ + 2
+          begin
+            raise RRError
+          rescue RRError => e
+            error = e
+          end
+          error.backtrace.first.should include(__FILE__)
+          error.backtrace.first.should include(expected_line.to_s)
         end
-        error.backtrace.first.should include(__FILE__)
-        error.backtrace.first.should include(expected_line.to_s)
       end
     end
   end

data/spec/rr/expectations/times_called_expectation/times_called_expectation_any_times_spec.rb

@@ -5,11 +5,12 @@ module RR
     describe TimesCalledExpectation do
       context "when using an AnyTimesMatcher" do
         it_should_behave_like "RR::Expectations::TimesCalledExpectation"
-        attr_reader :at_least, :expectation
+        attr_reader :matcher, :expectation
 
         before do
-          @at_least = TimesCalledMatchers::AnyTimesMatcher.new
-          @expectation = TimesCalledExpectation.new(double, at_least)
+          double.definition.any_number_of_times
+          @matcher = double.definition.times_matcher
+          @expectation = TimesCalledExpectation.new(double)
         end
 
         describe "#verify!" do

data/spec/rr/expectations/times_called_expectation/times_called_expectation_at_least_spec.rb

@@ -9,8 +9,9 @@ module RR
 
         before do
           @times = 3
-          @at_least = TimesCalledMatchers::AtLeastMatcher.new(times)
-          @expectation = TimesCalledExpectation.new(double, at_least)
+          double.definition.at_least(times)
+          @at_least = double.definition.times_matcher
+          @expectation = TimesCalledExpectation.new(double)
         end
 
         describe "#verify!" do

data/spec/rr/expectations/times_called_expectation/times_called_expectation_at_most_spec.rb

@@ -9,8 +9,9 @@ module RR
 
         before do
           @times = 3
-          @at_most = TimesCalledMatchers::AtMostMatcher.new(times)
-          @expectation = TimesCalledExpectation.new(double, at_most)
+          double.definition.at_most(times)
+          @at_most = double.definition.times_matcher
+          @expectation = TimesCalledExpectation.new(double)
         end
 
         describe "#verify!" do

data/spec/rr/expectations/times_called_expectation/times_called_expectation_helper.rb

@@ -1,7 +1,7 @@
 module RR
   module Expectations
     describe TimesCalledExpectation, :shared => true do
-      attr_reader :space, :subject, :method_name, :double_injection, :double, :double_definition
+      attr_reader :subject, :method_name, :double_injection, :double, :double_definition
       it_should_behave_like "Swapped Space"
       before do
         @subject = Object.new
@@ -12,7 +12,7 @@ module RR
           subject
         )
         @double = new_double(double_injection)
-        double.with_any_args
+        double.definition.with_any_args.any_number_of_times
       end
 
       def raises_expectation_error(&block)

data/spec/rr/expectations/times_called_expectation/times_called_expectation_integer_spec.rb

@@ -8,9 +8,9 @@ module RR
         attr_reader :matcher, :expected_line, :expectation
 
         before do
-          @matcher = TimesCalledMatchers::IntegerMatcher.new(2)
-          @expectation = TimesCalledExpectation.new(double, matcher)
-          @expected_line = __LINE__ - 1
+          double.definition.times(2)
+          @matcher = double.definition.times_matcher
+          @expectation = TimesCalledExpectation.new(double)
         end
 
         describe "#verify" do

data/spec/rr/expectations/times_called_expectation/times_called_expectation_proc_spec.rb

@@ -8,8 +8,9 @@ module RR
         attr_reader :matcher, :expectation
 
         before do
-          @matcher = TimesCalledMatchers::ProcMatcher.new(lambda {|value| value == 2})
-          @expectation = TimesCalledExpectation.new(double, matcher)
+          double.definition.times(lambda {|value| value == 2})
+          @matcher = double.definition.times_matcher
+          @expectation = TimesCalledExpectation.new(double)
         end
 
         describe "#verify" do
@@ -63,9 +64,9 @@ module RR
 
         describe "#attempt! for a lambda expectation" do
           it "lets everything pass" do
-            @subject.foobar
-            @subject.foobar
-            @subject.foobar
+            subject.foobar
+            subject.foobar
+            subject.foobar
           end
         end
 

data/spec/rr/expectations/times_called_expectation/times_called_expectation_range_spec.rb

@@ -8,8 +8,9 @@ module RR
         attr_reader :matcher, :expectation
 
         before do
-          @matcher = TimesCalledMatchers::RangeMatcher.new(1..2)
-          @expectation = TimesCalledExpectation.new(double, matcher)
+          double.definition.times(1..2)
+          @matcher = double.definition.times_matcher
+          @expectation = TimesCalledExpectation.new(double)
         end
 
         describe "#verify" do

data/spec/rr/expectations/times_called_expectation/times_called_expectation_spec.rb

@@ -9,8 +9,9 @@ module RR
 
         before do
           @times = 0
-          @matcher = TimesCalledMatchers::IntegerMatcher.new(times)
-          @expectation = TimesCalledExpectation.new(double, matcher)
+          double.definition.times(0)
+          @matcher = double.definition.times_matcher
+          @expectation = TimesCalledExpectation.new(double)
         end
 
         describe "#attempt!" do

data/spec/rr/rspec/invocation_matcher_spec.rb

@@ -0,0 +1,259 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module Adapters
+    module Rspec
+      describe InvocationMatcher do
+        describe "matching against a method with no doubles" do
+          before do
+            @matcher = InvocationMatcher.new(:foobar)
+            @result = @matcher.matches?(Object.new)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "defining an expectation using a method invocation" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar(:args)
+            @result = InvocationMatcher.new.foobar(:args).matches?(@subject)
+          end
+
+          it "uses the invoked method as the expected method" do
+            @result.should be
+          end
+        end
+
+        describe "matching against a stubbed method that was never called" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @matcher = InvocationMatcher.new(:foobar)
+            @result = @matcher.matches?(@subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching against a stubbed method that was called once" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar
+            @result = InvocationMatcher.new(:foobar).matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "matching against a stubbed method that was called with unexpected arguments" do
+          before do
+            @args = %w(one two)
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar(:other)
+            @result = InvocationMatcher.new(:foobar).with(*@args).matches?(@subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching against a stubbed method that was called with expected arguments" do
+          before do
+            @args = %w(one two)
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar(*@args)
+            @result = InvocationMatcher.new(:foobar).with(*@args).matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "defining a fulfilled argument expectation using a method invocation" do
+          before do
+            @args = %w(one two)
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar(*@args)
+            @result = InvocationMatcher.new.foobar(*@args).matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "defining an unfulfilled argument expectation using a method invocation" do
+          before do
+            @args = %w(one two)
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar(:other)
+            @result = InvocationMatcher.new.foobar(*@args).matches?(@subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching against a stubbed method that was called more than once" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            2.times { @subject.foobar }
+            @result = InvocationMatcher.new(:foobar).twice.matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "matching a stubbed method with any arguments" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar(:args)
+            @result = InvocationMatcher.new(:foobar).with_any_args.matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "matching a stubbed method with no arguments when arguments are not provided" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar
+            @result = InvocationMatcher.new(:foobar).with_no_args.matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "matching a stubbed method with no arguments when arguments are provided" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar(:args)
+            @result = InvocationMatcher.new(:foobar).with_no_args.matches?(@subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called twice when expected once" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            2.times { @subject.foobar }
+            @matcher = InvocationMatcher.new(:foobar).times(1)
+            @result = @matcher.matches?(@subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called twice when expected twice" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            2.times { @subject.foobar }
+            @result = InvocationMatcher.new(:foobar).times(2).matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "matching a method that was called twice when any number of times" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            2.times { @subject.foobar }
+            @result = InvocationMatcher.new(:foobar).any_number_of_times.matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "matching a method that was called three times when expected at most twice" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            3.times { @subject.foobar }
+            @result = InvocationMatcher.new(:foobar).at_most(2).matches?(@subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called once when expected at most twice" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar
+            @result = InvocationMatcher.new(:foobar).at_most(2).matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+
+        describe "matching a method that was called once when expected at least twice" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            @subject.foobar
+            @result = InvocationMatcher.new(:foobar).at_least(2).matches?(@subject)
+          end
+
+          it "does not match" do
+            @result.should_not be
+          end
+        end
+
+        describe "matching a method that was called three times when expected at least twice" do
+          before do
+            @subject = Object.new
+            stub(@subject).foobar
+            3.times { @subject.foobar }
+            @result = InvocationMatcher.new(:foobar).at_least(2).matches?(@subject)
+          end
+
+          it "does match" do
+            @result.should be
+          end
+        end
+      end
+    end
+  end
+end