rr 0.4.2 → 0.4.3

data/CHANGES

@@ -1,3 +1,8 @@
+* 0.4.3
+- Doc improvements
+- Cleanup
+- Finished renaming scenario to double
+
 * 0.4.2
 - Renamed DoubleInsertion to DoubleInjection to be consistent with Mocha terminology
 

data/README

@@ -17,6 +17,19 @@ http://xunitpatterns.com/Test%20Double.html
 Currently RR implements mocks, stubs, and proxies. In the future, RR will
 support spies.
 
+== Using RR
+=== test/unit
+  class Test::Unit::TestCase
+    include RR::Adapters::TestUnit
+  end
+
+=== rspec
+  Spec::Runners.configure do |config|
+    config.mock_with :rr
+    # or if that doesn't work due to a version incompatibility
+    # config.mock_with RR::Adapters::Rspec
+  end
+
 == Syntax between RR and other double/mock frameworks
 === Terse Syntax
 One of the goals of RR is to make doubles more scannable.

data/Rakefile

@@ -26,7 +26,7 @@ def run_suite
 end
 
 PKG_NAME = "rr"
-PKG_VERSION = "0.4.2"
+PKG_VERSION = "0.4.3"
 PKG_FILES = FileList[
   '[A-Z]*',
   '*.rb',

data/lib/rr.rb

@@ -1,8 +1,8 @@
 dir = File.dirname(__FILE__)
 require "#{dir}/rr/errors/rr_error"
-require "#{dir}/rr/errors/scenario_definition_error"
-require "#{dir}/rr/errors/scenario_not_found_error"
-require "#{dir}/rr/errors/scenario_order_error"
+require "#{dir}/rr/errors/double_definition_error"
+require "#{dir}/rr/errors/double_not_found_error"
+require "#{dir}/rr/errors/double_order_error"
 require "#{dir}/rr/errors/argument_equality_error"
 require "#{dir}/rr/errors/times_called_error"
 

data/lib/rr/adapters/rr_methods.rb

@@ -41,7 +41,7 @@ module RR
       #     method_name_2(arg_1, arg_2) {return_value_2}
       #   end
       def mock(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.scenario_creator
+        creator = RR::Space.double_creator
         creator.mock(subject, method_name, &definition)
       end
 
@@ -75,7 +75,7 @@ module RR
       #     method_name_2(arg_1, arg_2) {return_value_2}
       #   end
       def stub(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.scenario_creator
+        creator = RR::Space.double_creator
         creator.stub(subject, method_name, &definition)
       end
 
@@ -125,7 +125,7 @@ module RR
       #     "My new return value"
       #   end
       def proxy(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.scenario_creator
+        creator = RR::Space.double_creator
         creator.proxy(subject, method_name, &definition)
       end
 
@@ -146,7 +146,7 @@ module RR
       #      m.method3.with_no_args # Do not allow method3 with no arguments
       #    end
       def dont_allow(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.scenario_creator
+        creator = RR::Space.double_creator
         creator.dont_allow(subject, method_name, &definition)
       end
       alias_method :do_not_allow, :dont_allow
@@ -165,7 +165,7 @@ module RR
       #     projects[0..2]
       #   end
       def instance_of(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.scenario_creator
+        creator = RR::Space.double_creator
         creator.instance_of(subject, method_name, &definition)
       end
 

data/lib/rr/double.rb

@@ -9,9 +9,9 @@ module RR
         "#{method_name}(#{formatted_errors})"
       end
 
-      def list_message_part(scenarios)
-        scenarios.collect do |scenario|
-          "- #{formatted_name(scenario.method_name, scenario.expected_arguments)}"
+      def list_message_part(doubles)
+        doubles.collect do |double|
+          "- #{formatted_name(double.method_name, double.expected_arguments)}"
         end.join("\n")
       end
     end
@@ -218,7 +218,7 @@ module RR
     # exceeds the expected TimesCalledExpectation.
     def call(double_insertion, *args, &block)
       self.times_called_expectation.attempt! if definition.times_matcher
-      @space.verify_ordered_scenario(self) if ordered?
+      @space.verify_ordered_double(self) if ordered?
       yields!(block)
       return_value = call_implementation(double_insertion, *args, &block)
       return return_value unless definition.after_call_value
@@ -280,7 +280,7 @@ module RR
     end
 
     # Double#verify verifies the the TimesCalledExpectation
-    # is satisfied for this scenario. A TimesCalledError
+    # is satisfied for this double. A TimesCalledError
     # is raised if the TimesCalledExpectation is not met.
     def verify
       return true unless definition.times_matcher

data/lib/rr/double_creator.rb

@@ -50,7 +50,7 @@ module RR
       strategy_error! if @strategy
       @strategy = :mock
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+      RR::Space.double_method_proxy(self, subject, method_name, &definition)
     end
 
     # This method sets the Double to have a stub strategy. A stub strategy
@@ -85,7 +85,7 @@ module RR
       strategy_error! if @strategy
       @strategy = :stub
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+      RR::Space.double_method_proxy(self, subject, method_name, &definition)
     end
 
     # This method sets the Double to have a dont_allow strategy.
@@ -109,7 +109,7 @@ module RR
       proxy_when_dont_allow_error! if @proxy
       @strategy = :dont_allow
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+      RR::Space.double_method_proxy(self, subject, method_name, &definition)
     end
     alias_method :do_not_allow, :dont_allow
     alias_method :dont_call, :dont_allow
@@ -164,7 +164,7 @@ module RR
       proxy_when_dont_allow_error! if @strategy == :dont_allow
       @proxy = true
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+      RR::Space.double_method_proxy(self, subject, method_name, &definition)
     end
     alias_method :probe, :proxy
 
@@ -183,7 +183,7 @@ module RR
       @instance_of = true
       return self if subject === NO_SUBJECT_ARG
       raise ArgumentError, "instance_of only accepts class objects" unless subject.is_a?(Class)
-      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+      RR::Space.double_method_proxy(self, subject, method_name, &definition)
     end
 
     def create!(subject, method_name, *args, &handler)
@@ -192,34 +192,34 @@ module RR
       if @instance_of
         setup_class_probing_instances(subject, method_name)
       else
-        setup_scenario(subject, method_name)
+        setup_double(subject, method_name)
       end
       transform!
       @definition
     end
     
     protected
-    def setup_scenario(subject, method_name)
+    def setup_double(subject, method_name)
       @double_insertion = @space.double_insertion(subject, method_name)
-      @scenario = @space.scenario(@double_insertion)
-      @definition = @scenario.definition
+      @double = @space.double(@double_insertion)
+      @definition = @double.definition
     end
 
     def setup_class_probing_instances(subject, method_name)
       class_double = @space.double_insertion(subject, :new)
-      class_scenario = @space.scenario(class_double)
+      class_double = @space.double(class_double)
 
       instance_method_name = method_name
 
-      @definition = @space.scenario_definition
+      @definition = @space.double_definition
       class_handler = proc do |return_value|
         double_insertion = @space.double_insertion(return_value, instance_method_name)
-        @space.scenario(double_insertion, @definition)
+        @space.double(double_insertion, @definition)
         return_value
       end
 
       builder = DoubleDefinitionBuilder.new(
-        class_scenario.definition,
+        class_double.definition,
         [],
         class_handler
       )

data/lib/rr/double_definition.rb

@@ -10,7 +10,7 @@ module RR
                   :implementation,
                   :after_call_value,
                   :yields_value,
-                  :scenario
+                  :double
     attr_reader   :block_callback_strategy
 
     def initialize(space)
@@ -157,9 +157,9 @@ module RR
         "Double Definitions must have a dedicated Double to be ordered. " <<
         "For example, using instance_of does not allow ordered to be used. " <<
         "proxy the class's #new method instead."
-      ) unless @scenario
+      ) unless @double
       @ordered = true
-      @space.ordered_scenarios << @scenario unless @space.ordered_scenarios.include?(@scenario)
+      @space.ordered_doubles << @double unless @space.ordered_doubles.include?(@double)
       install_method_callback returns
       self
     end

data/lib/rr/double_injection.rb

@@ -4,7 +4,7 @@ module RR
   # has Argument Expectations and Times called Expectations.
   class DoubleInjection
     MethodArguments = Struct.new(:arguments, :block)
-    attr_reader :space, :object, :method_name, :scenarios
+    attr_reader :space, :object, :method_name, :doubles
 
     def initialize(space, object, method_name)
       @space = space
@@ -13,13 +13,13 @@ module RR
       if object_has_method?(method_name)
         meta.send(:alias_method, original_method_name, method_name)
       end
-      @scenarios = []
+      @doubles = []
     end
 
-    # RR::DoubleInjection#register_scenario adds the passed in Double
+    # RR::DoubleInjection#register_double adds the passed in Double
     # into this DoubleInjection's list of Double objects.
-    def register_scenario(scenario)
-      @scenarios << scenario
+    def register_double(double)
+      @doubles << double
     end
 
     # RR::DoubleInjection#bind injects a method that acts as a dispatcher
@@ -39,8 +39,8 @@ module RR
     # RR::DoubleInjection#verify verifies each Double
     # TimesCalledExpectation are met.
     def verify
-      @scenarios.each do |scenario|
-        scenario.verify
+      @doubles.each do |double|
+        double.verify
       end
     end
 
@@ -74,42 +74,42 @@ module RR
     end
 
     def call_method(args, block)
-      if scenario = find_scenario_to_attempt(args)
-        return scenario.call(self, *args, &block)
+      if double = find_double_to_attempt(args)
+        return double.call(self, *args, &block)
       end
-      scenario_not_found_error(*args)
+      double_not_found_error(*args)
     end
 
-    def find_scenario_to_attempt(args)
-      matches = DoubleMatches.new(@scenarios).find_all_matches!(args)
+    def find_double_to_attempt(args)
+      matches = DoubleMatches.new(@doubles).find_all_matches!(args)
 
-      unless matches.exact_terminal_scenarios_to_attempt.empty?
-        return matches.exact_terminal_scenarios_to_attempt.first
+      unless matches.exact_terminal_doubles_to_attempt.empty?
+        return matches.exact_terminal_doubles_to_attempt.first
       end
 
-      unless matches.exact_non_terminal_scenarios_to_attempt.empty?
-        return matches.exact_non_terminal_scenarios_to_attempt.last
+      unless matches.exact_non_terminal_doubles_to_attempt.empty?
+        return matches.exact_non_terminal_doubles_to_attempt.last
       end
 
-      unless matches.wildcard_terminal_scenarios_to_attempt.empty?
-        return matches.wildcard_terminal_scenarios_to_attempt.first
+      unless matches.wildcard_terminal_doubles_to_attempt.empty?
+        return matches.wildcard_terminal_doubles_to_attempt.first
       end
 
-      unless matches.wildcard_non_terminal_scenarios_to_attempt.empty?
-        return matches.wildcard_non_terminal_scenarios_to_attempt.last
+      unless matches.wildcard_non_terminal_doubles_to_attempt.empty?
+        return matches.wildcard_non_terminal_doubles_to_attempt.last
       end
 
-      unless matches.matching_scenarios.empty?
+      unless matches.matching_doubles.empty?
         # This will raise a TimesCalledError
-        return matches.matching_scenarios.first
+        return matches.matching_doubles.first
       end
 
       return nil
     end
 
-    def scenario_not_found_error(*args)
+    def double_not_found_error(*args)
       message = "Unexpected method invocation #{Double.formatted_name(@method_name, args)}, expected\n"
-      message << Double.list_message_part(@scenarios)
+      message << Double.list_message_part(@doubles)
       raise Errors::DoubleNotFoundError, message
     end
 

data/lib/rr/double_matches.rb

@@ -1,30 +1,30 @@
 module RR
 class DoubleMatches
-  attr_reader :matching_scenarios,
-              :exact_terminal_scenarios_to_attempt,
-              :exact_non_terminal_scenarios_to_attempt,
-              :wildcard_terminal_scenarios_to_attempt,
-              :wildcard_non_terminal_scenarios_to_attempt
-  def initialize(scenarios) #:nodoc:
-    @scenarios = scenarios
-    @matching_scenarios = []
-    @exact_terminal_scenarios_to_attempt = []
-    @exact_non_terminal_scenarios_to_attempt = []
-    @wildcard_terminal_scenarios_to_attempt = []
-    @wildcard_non_terminal_scenarios_to_attempt = []
+  attr_reader :matching_doubles,
+              :exact_terminal_doubles_to_attempt,
+              :exact_non_terminal_doubles_to_attempt,
+              :wildcard_terminal_doubles_to_attempt,
+              :wildcard_non_terminal_doubles_to_attempt
+  def initialize(doubles) #:nodoc:
+    @doubles = doubles
+    @matching_doubles = []
+    @exact_terminal_doubles_to_attempt = []
+    @exact_non_terminal_doubles_to_attempt = []
+    @wildcard_terminal_doubles_to_attempt = []
+    @wildcard_non_terminal_doubles_to_attempt = []
   end
 
   def find_all_matches!(args)
-    @scenarios.each do |scenario|
-      if scenario.exact_match?(*args)
-        matching_scenarios << scenario
-        if scenario.attempt?
-          exact_scenario_is_terminal_or_non_terminal scenario
+    @doubles.each do |double|
+      if double.exact_match?(*args)
+        matching_doubles << double
+        if double.attempt?
+          exact_double_is_terminal_or_non_terminal double
         end
-      elsif scenario.wildcard_match?(*args)
-        matching_scenarios << scenario
-        if scenario.attempt?
-          wildcard_scenario_is_terminal_or_non_terminal scenario
+      elsif double.wildcard_match?(*args)
+        matching_doubles << double
+        if double.attempt?
+          wildcard_double_is_terminal_or_non_terminal double
         end
       end
     end
@@ -32,19 +32,19 @@ class DoubleMatches
   end
 
   protected
-  def exact_scenario_is_terminal_or_non_terminal(scenario)
-    if scenario.terminal?
-      exact_terminal_scenarios_to_attempt << scenario
+  def exact_double_is_terminal_or_non_terminal(double)
+    if double.terminal?
+      exact_terminal_doubles_to_attempt << double
     else
-      exact_non_terminal_scenarios_to_attempt << scenario
+      exact_non_terminal_doubles_to_attempt << double
     end
   end
 
-  def wildcard_scenario_is_terminal_or_non_terminal(scenario)
-    if scenario.terminal?
-      wildcard_terminal_scenarios_to_attempt << scenario
+  def wildcard_double_is_terminal_or_non_terminal(double)
+    if double.terminal?
+      wildcard_terminal_doubles_to_attempt << double
     else
-      wildcard_non_terminal_scenarios_to_attempt << scenario
+      wildcard_non_terminal_doubles_to_attempt << double
     end
   end
 end

data/lib/rr/expectations/times_called_expectation.rb

@@ -1,11 +1,11 @@
 module RR
   module Expectations
     class TimesCalledExpectation #:nodoc:
-      attr_reader :scenario, :times_called
+      attr_reader :double, :times_called
       attr_accessor :matcher
 
-      def initialize(scenario, matcher=nil)
-        @scenario = scenario
+      def initialize(double, matcher=nil)
+        @double = double
         @matcher = matcher
         @times_called = 0
         @verify_backtrace = caller[1..-1]
@@ -48,7 +48,7 @@ module RR
       end
 
       def error_message
-        "#{scenario.formatted_name}\n#{@matcher.error_message(@times_called)}"
+        "#{double.formatted_name}\n#{@matcher.error_message(@times_called)}"
       end
     end
   end

data/lib/rr/space.rb

@@ -15,15 +15,15 @@ module RR
       end
     end
 
-    attr_reader :double_insertions, :ordered_scenarios
+    attr_reader :double_insertions, :ordered_doubles
     attr_accessor :trim_backtrace
     def initialize
       @double_insertions = HashWithObjectIdKey.new
-      @ordered_scenarios = []
+      @ordered_doubles = []
       @trim_backtrace = false
     end
 
-    def scenario_method_proxy(creator, object, method_name=nil, &definition)
+    def double_method_proxy(creator, object, method_name=nil, &definition)
       if method_name && definition
         raise ArgumentError, "Cannot pass in a method name and a block"
       end
@@ -33,19 +33,19 @@ module RR
     end
 
     # Creates a DoubleCreator.
-    def scenario_creator
+    def double_creator
       DoubleCreator.new(self)
     end
 
     # Creates and registers a Double to be verified.
-    def scenario(double_insertion, definition = scenario_definition)
-      scenario = Double.new(self, double_insertion, definition)
-      scenario.definition.scenario = scenario
-      double_insertion.register_scenario scenario
-      scenario
+    def double(double_insertion, definition = double_definition)
+      double = Double.new(self, double_insertion, definition)
+      double.definition.double = double
+      double_insertion.register_double double
+      double
     end
 
-    def scenario_definition
+    def double_definition
       DoubleDefinition.new(self)
     end
 
@@ -64,25 +64,25 @@ module RR
     end
 
     # Registers the ordered Double to be verified.
-    def register_ordered_scenario(scenario)
-      @ordered_scenarios << scenario
+    def register_ordered_double(double)
+      @ordered_doubles << double
     end
 
     # Verifies that the passed in ordered Double is being called
     # in the correct position.
-    def verify_ordered_scenario(scenario)
-      unless scenario.terminal?
+    def verify_ordered_double(double)
+      unless double.terminal?
         raise Errors::DoubleOrderError,
               "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
       end
-      unless @ordered_scenarios.first == scenario
-        message = Double.formatted_name(scenario.method_name, scenario.expected_arguments)
+      unless @ordered_doubles.first == double
+        message = Double.formatted_name(double.method_name, double.expected_arguments)
         message << " called out of order in list\n"
-        message << Double.list_message_part(@ordered_scenarios)
+        message << Double.list_message_part(@ordered_doubles)
         raise Errors::DoubleOrderError, message
       end
-      @ordered_scenarios.shift unless scenario.attempt?
-      scenario
+      @ordered_doubles.shift unless double.attempt?
+      double
     end
 
     # Verifies all the DoubleInjection objects have met their
@@ -97,7 +97,7 @@ module RR
 
     # Resets the registered Doubles and ordered Doubles
     def reset
-      reset_ordered_scenarios
+      reset_ordered_doubles
       reset_double_insertions
     end
 
@@ -117,8 +117,8 @@ module RR
 
     protected
     # Removes the ordered Doubles from the list
-    def reset_ordered_scenarios
-      @ordered_scenarios.clear
+    def reset_ordered_doubles
+      @ordered_doubles.clear
     end
 
     # Resets the registered Doubles for the next test run.