rr 0.1.6 → 0.1.7

data/examples/rr/times_called_matchers/range_matcher_example.rb

@@ -0,0 +1,94 @@
+require "examples/example_helper"
+
+module RR
+module TimesCalledMatchers
+  describe TimesCalledMatcher, ".create when passed a IntegerMatcher" do
+    it "returns the passed in argument" do
+      matcher = RangeMatcher.new(2..4)
+      TimesCalledMatcher.create(matcher).should === matcher
+    end
+  end
+
+  describe TimesCalledMatcher, ".create when passed a Integer" do
+    it "returns RangeMatcher" do
+      TimesCalledMatcher.create(2..4).should == RangeMatcher.new(2..4)
+    end
+  end
+
+  describe RangeMatcher, "#possible_match?" do
+    before do
+      @times = 2..4
+      @matcher = RangeMatcher.new(@times)
+    end
+
+    it "returns true when times called < start of range" do
+      @matcher.should be_possible_match(1)
+    end
+
+    it "returns true when times called in range" do
+      @matcher.should be_possible_match(2)
+      @matcher.should be_possible_match(3)
+      @matcher.should be_possible_match(4)
+    end
+
+    it "returns false when times called > end of range" do
+      @matcher.should_not be_possible_match(5)
+    end
+  end
+
+  describe RangeMatcher, "#matches?" do
+    before do
+      @times = 2..4
+      @matcher = RangeMatcher.new(@times)
+    end
+
+    it "returns false when times_called less than start of range" do
+      @matcher.should_not be_matches(1)
+    end
+
+    it "returns true when times_called in range" do
+      @matcher.should be_matches(2)
+      @matcher.should be_matches(3)
+      @matcher.should be_matches(4)
+    end
+
+    it "returns false when times_called > end of range" do
+      @matcher.should_not be_matches(5)
+    end
+  end
+
+  describe RangeMatcher, "#attempt?" do
+    before do
+      @times = 2..4
+      @matcher = RangeMatcher.new(@times)
+    end
+
+    it "returns true when less than start of range" do
+      @matcher.should be_attempt(1)
+    end
+
+    it "returns true when in range" do
+      @matcher.should be_attempt(2)
+      @matcher.should be_attempt(3)
+      @matcher.should be_attempt(4)
+    end
+
+    it "returns false when > end of range" do
+      @matcher.should_not be_attempt(5)
+    end
+  end
+
+  describe RangeMatcher, "#error_message" do
+    before do
+      @times = 2..4
+      @matcher = RangeMatcher.new(@times)
+    end
+
+    it "has an error message" do
+      @matcher.error_message(1).should == (
+        "Called 1 time. Expected 2..4 times."
+      )
+    end
+  end
+end
+end

data/examples/rr/times_called_matchers/times_called_matcher_example.rb

@@ -0,0 +1,53 @@
+require "examples/example_helper"
+
+module RR
+module TimesCalledMatchers
+  describe TimesCalledMatcher, ".create when passed a TimesCalledMatcher" do
+    it "returns the passed in argument" do
+      matcher = TimesCalledMatcher.new(5)
+      TimesCalledMatcher.create(matcher).should === matcher
+    end
+  end
+
+  describe TimesCalledMatcher, ".create when passed an unsupported type" do
+    it "raises an ArgumentError" do
+      matcher = Object.new
+      proc do
+        TimesCalledMatcher.create(matcher)
+      end.should raise_error(ArgumentError, "There is no TimesCalledMatcher for #{matcher.inspect}.")
+    end
+  end
+
+  describe TimesCalledMatcher, "#error_message" do
+    before do
+      @times = 3
+      @matcher = TimesCalledMatcher.new(@times)
+    end
+
+    it "has an error message" do
+      @matcher.error_message(5).should == (
+        "Called 5 times. Expected 3 times."
+      )
+    end
+  end
+
+  describe TimesCalledMatcher, "#==" do
+    before do
+      @times = 3
+      @matcher = TimesCalledMatcher.new(@times)
+    end
+
+    it "returns true when other is the same class and times are ==" do
+      @matcher.should == TimesCalledMatcher.new(@times)
+    end
+
+    it "returns false when other is a different class and times are ==" do
+      @matcher.should_not == IntegerMatcher.new(@times)
+    end
+
+    it "returns false when is the same class and times are not ==" do
+      @matcher.should_not == TimesCalledMatcher.new(1)
+    end
+  end
+end
+end

data/lib/rr.rb

@@ -19,12 +19,20 @@ require "rr/errors/times_called_error"
 require "rr/expectations/argument_equality_expectation"
 require "rr/expectations/any_argument_expectation"
 require "rr/expectations/times_called_expectation"
-require "rr/expectations/wildcard_matchers/anything"
-require "rr/expectations/wildcard_matchers/is_a"
-require "rr/expectations/wildcard_matchers/numeric"
-require "rr/expectations/wildcard_matchers/boolean"
-require "rr/expectations/wildcard_matchers/duck_type"
-require "rr/expectations/wildcard_matchers/regexp"
-require "rr/expectations/wildcard_matchers/range"
+
+require "rr/wildcard_matchers/anything"
+require "rr/wildcard_matchers/is_a"
+require "rr/wildcard_matchers/numeric"
+require "rr/wildcard_matchers/boolean"
+require "rr/wildcard_matchers/duck_type"
+require "rr/wildcard_matchers/regexp"
+require "rr/wildcard_matchers/range"
+
+require "rr/times_called_matchers/times_called_matcher"
+require "rr/times_called_matchers/integer_matcher"
+require "rr/times_called_matchers/range_matcher"
+require "rr/times_called_matchers/proc_matcher"
+require "rr/times_called_matchers/at_least_matcher"
+require "rr/times_called_matchers/at_most_matcher"
 
 require "rr/extensions/double_methods"

data/lib/rr/adapters/rspec.rb

@@ -6,13 +6,13 @@ module RR
     module Rspec
       include RR::Extensions::DoubleMethods
       def setup_mocks_for_rspec
-        RR::Space.instance.reset_doubles
+        RR::Space.instance.reset
       end
       def verify_mocks_for_rspec
         RR::Space.instance.verify_doubles
       end
       def teardown_mocks_for_rspec
-        RR::Space.instance.reset_doubles
+        RR::Space.instance.reset
       end
     end
   end

data/lib/rr/adapters/test_unit.rb

@@ -9,7 +9,7 @@ module RR
           alias_method :setup_without_rr, :setup
           def setup_with_rr
             setup_without_rr
-            RR::Space.instance.reset_doubles
+            RR::Space.instance.reset
           end
           alias_method :setup, :setup_with_rr
 

data/lib/rr/double.rb

@@ -67,13 +67,13 @@ module RR
       @scenarios.each do |scenario|
         if scenario.exact_match?(*args)
           matching_scenarios << scenario
-          return scenario.call(*args, &block) unless scenario.times_called_verified?
+          return scenario.call(*args, &block) if scenario.attempt?
         end
       end
       @scenarios.each do |scenario|
         if scenario.wildcard_match?(*args)
           matching_scenarios << scenario
-          return scenario.call(*args, &block) unless scenario.times_called_verified?
+          return scenario.call(*args, &block) if scenario.attempt?
         end
       end
       matching_scenarios.first.call(*args) unless matching_scenarios.empty?

data/lib/rr/expectations/times_called_expectation.rb

@@ -1,27 +1,29 @@
 module RR
   module Expectations
     class TimesCalledExpectation
-      attr_reader :times, :times_called
+      attr_reader :matcher, :times_called
       
-      def initialize(times=nil, &time_condition_block)
-        raise ArgumentError, "Cannot pass in both an argument and a block" if times && time_condition_block
-        @times = times || time_condition_block
+      def initialize(matcher=nil, &time_condition_block)
+        raise ArgumentError, "Cannot pass in both an argument and a block" if matcher && time_condition_block
+        matcher_value = matcher || time_condition_block
+        @matcher = TimesCalledMatchers::TimesCalledMatcher.create(matcher_value)
         @times_called = 0
         @verify_backtrace = caller[1..-1]
       end
 
-      def verify_input
+      def attempt?
+        @matcher.attempt?(@times_called)
+      end
+
+      def attempt!
         @times_called += 1
-        verify_input_error if @times.is_a?(Integer) && @times_called > @times
-        verify_input_error if @times.is_a?(Range) && @times_called > @times.end
+        verify_input_error unless @matcher.possible_match?(@times_called)
         return
       end
 
       def verify
-        return true if @times.is_a?(Integer) && @times == @times_called
-        return true if @times.is_a?(Proc) && @times.call(@times_called)
-        return true if @times.is_a?(Range) && @times.include?(@times_called)
-        return false
+        return false unless @matcher.is_a?(TimesCalledMatchers::TimesCalledMatcher)
+        return @matcher.matches?(@times_called)
       end
 
       def verify!
@@ -42,8 +44,7 @@ module RR
       end
 
       def error_message
-        time_casing = (@times_called == 1) ? "time" : "times"
-        "Called #{@times_called.inspect} #{time_casing}. Expected #{@times.inspect}."
+        @matcher.error_message(@times_called)
       end
     end
   end

data/lib/rr/extensions/double_methods.rb

@@ -35,7 +35,7 @@ module Extensions
     #   mock(object).method_name(anything) {return_value}
     #   object.method_name("an arbitrary value") # passes
     def anything
-      RR::Expectations::WildcardMatchers::Anything.new
+      RR::WildcardMatchers::Anything.new
     end
 
     # Sets up an IsA wildcard ArgumentEqualityError
@@ -43,7 +43,7 @@ module Extensions
     #   mock(object).method_name(is_a(String)) {return_value}
     #   object.method_name("A String") # passes
     def is_a(klass)
-      RR::Expectations::WildcardMatchers::IsA.new(klass)
+      RR::WildcardMatchers::IsA.new(klass)
     end
 
     # Sets up an Numeric wildcard ArgumentEqualityError
@@ -51,7 +51,7 @@ module Extensions
     #   mock(object).method_name(numeric) {return_value}
     #   object.method_name(99) # passes
     def numeric
-      RR::Expectations::WildcardMatchers::Numeric.new
+      RR::WildcardMatchers::Numeric.new
     end
 
     # Sets up an Boolean wildcard ArgumentEqualityError
@@ -59,7 +59,7 @@ module Extensions
     #   mock(object).method_name(boolean) {return_value}
     #   object.method_name(false) # passes
     def boolean
-      RR::Expectations::WildcardMatchers::Boolean.new
+      RR::WildcardMatchers::Boolean.new
     end
 
     # Sets up a DuckType wildcard ArgumentEqualityError
@@ -70,7 +70,7 @@ module Extensions
     #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
     #   object.method_name(arg) # passes
     def duck_type(*args)
-      RR::Expectations::WildcardMatchers::DuckType.new(*args)
+      RR::WildcardMatchers::DuckType.new(*args)
     end
 
     instance_methods.each do |name|

data/lib/rr/scenario.rb

@@ -83,7 +83,35 @@ module RR
       self
     end
 
-    # Scenario#twice creates an TimesCalledExpectation of the passed
+    # Scenario#at_least allows you to set an expectation that the Scenario
+    # will be called at least n times.
+    # It works by creating a TimesCalledExpectation.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.at_least(4) {:return_value}
+    def at_least(number, &returns)
+      matcher = RR::TimesCalledMatchers::AtLeastMatcher.new(number)
+      @times_called_expectation = Expectations::TimesCalledExpectation.new(matcher)
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#at_most allows you to set an expectation that the Scenario
+    # will be called at most n times.
+    # It works by creating a TimesCalledExpectation.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.at_most(4) {:return_value}
+    def at_most(number, &returns)
+      matcher = RR::TimesCalledMatchers::AtMostMatcher.new(number)
+      @times_called_expectation = Expectations::TimesCalledExpectation.new(matcher)
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#times creates an TimesCalledExpectation of the passed
     # in number.
     #
     # Passing in a block sets the return value.
@@ -188,7 +216,7 @@ module RR
     end
 
     def call_implementation(*args, &block)
-      @times_called_expectation.verify_input if @times_called_expectation
+      @times_called_expectation.attempt! if @times_called_expectation
       @space.verify_ordered_scenario(self) if ordered?
       if @yields
         unless block
@@ -221,11 +249,11 @@ module RR
       @argument_expectation.wildcard_match?(*arguments)
     end
 
-    # Scenario#times_called_verified? returns true when the
+    # Scenario#attempt? returns true when the
     # TimesCalledExpectation is satisfied.
-    def times_called_verified?
-      return false unless @times_called_expectation
-      @times_called_expectation.verify
+    def attempt?
+      return true unless @times_called_expectation
+      @times_called_expectation.attempt?
     end
 
     # Scenario#verify verifies the the TimesCalledExpectation
@@ -237,4 +265,4 @@ module RR
       true
     end
   end
-end
+end

data/lib/rr/space.rb

@@ -73,7 +73,7 @@ module RR
     # in the correct position.
     def verify_ordered_scenario(scenario)
       raise Errors::ScenarioOrderError unless @ordered_scenarios.first == scenario
-      @ordered_scenarios.shift if scenario.times_called_verified?
+      @ordered_scenarios.shift unless scenario.attempt?
       scenario
     end
 
@@ -87,13 +87,10 @@ module RR
       end
     end
 
-    # Resets the registered Doubles for the next test run.
-    def reset_doubles
-      @doubles.each do |object, method_double_map|
-        method_double_map.keys.each do |method_name|
-          reset_double(object, method_name)
-        end
-      end
+    # Resets the registered Doubles and ordered Scenarios
+    def reset
+      reset_ordered_scenarios
+      reset_doubles
     end
 
     # Verifies the Double for the passed in object and method_name.
@@ -109,5 +106,20 @@ module RR
       @doubles.delete(object) if @doubles[object].empty?
       double.reset
     end
+
+    protected
+    # Removes the ordered Scenarios from the list
+    def reset_ordered_scenarios
+      @ordered_scenarios.clear
+    end
+
+    # Resets the registered Doubles for the next test run.
+    def reset_doubles
+      @doubles.each do |object, method_double_map|
+        method_double_map.keys.each do |method_name|
+          reset_double(object, method_name)
+        end
+      end
+    end    
   end
 end

data/lib/rr/times_called_matchers/at_least_matcher.rb

@@ -0,0 +1,22 @@
+module RR
+module TimesCalledMatchers
+  class AtLeastMatcher < TimesCalledMatcher
+    def possible_match?(times_called)
+      true
+    end
+
+    def matches?(times_called)
+      times_called >= @times
+    end
+
+    def attempt?(times_called)
+      times_called < @times
+    end
+
+    protected
+    def expected_message_part
+      "Expected at least #{@times.inspect} times."
+    end
+  end
+end
+end