rr 0.1.0

data/examples/rr/stub_creator_example.rb

@@ -0,0 +1,74 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../example_helper"
+
+module RR
+describe StubCreator, :shared => true do
+  before(:each) do
+    @space = Space.new
+    @subject = Object.new
+  end
+
+  it "initializes creator with passed in object" do
+    class << @creator
+      attr_reader :subject
+    end
+    @creator.subject.should === @subject
+  end
+end
+
+describe StubCreator, ".new without block" do
+  it_should_behave_like "RR::StubCreator"
+
+  before do
+    @creator = StubCreator.new(@space, @subject)
+  end
+end
+
+describe StubCreator, ".new with block" do
+  it_should_behave_like "RR::StubCreator"
+
+  before do
+    @creator = StubCreator.new(@space, @subject) do |c|
+      c.foobar(1, 2) {:one_two}
+      c.foobar(1) {:one}
+      c.foobar.with_any_args {:default}
+      c.baz() {:baz_result}
+    end
+  end
+
+  it "creates doubles" do
+    @subject.foobar(1, 2).should == :one_two
+    @subject.foobar(1, 2).should == :one_two
+    @subject.foobar(1).should == :one
+    @subject.foobar(1).should == :one
+    @subject.foobar(:something).should == :default
+    @subject.foobar(:something).should == :default
+    @subject.baz.should == :baz_result
+    @subject.baz.should == :baz_result
+  end
+end
+
+describe StubCreator, "#method_missing" do
+  it_should_behave_like "RR::StubCreator"
+  
+  before do
+    @subject = Object.new
+    @creator = StubCreator.new(@space, @subject)
+  end
+
+  it "stubs the subject without any args" do
+    @creator.foobar {:baz}
+    @subject.foobar.should == :baz
+  end
+
+  it "stubs the subject mapping passed in args with the output" do
+    @creator.foobar(1, 2) {:one_two}
+    @creator.foobar(1) {:one}
+    @creator.foobar() {:nothing}
+    @subject.foobar.should == :nothing
+    @subject.foobar(1).should == :one
+    @subject.foobar(1, 2).should == :one_two
+  end
+end
+
+end

data/examples/rr/test_unit/test_helper.rb

@@ -0,0 +1,9 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../../environment_fixture_setup"
+require "rr/adapters/test_unit"
+
+require "test/unit"
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end

data/examples/rr/test_unit/test_unit_integration_test.rb

@@ -0,0 +1,39 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/test_helper"
+
+class TestUnitIntegrationTest < Test::Unit::TestCase
+  def setup
+    super
+    @subject = Object.new
+  end
+
+  def teardown
+    super
+  end
+
+  def test_using_a_mock
+    mock(@subject).foobar(1, 2) {:baz}
+    assert_equal :baz, @subject.foobar(1, 2)
+  end
+  
+  def test_using_a_stub
+    stub(@subject).foobar {:baz}
+    assert_equal :baz, @subject.foobar("any", "thing")
+  end
+
+  def test_using_a_probe
+    def @subject.foobar
+      :baz
+    end
+
+    probe(@subject).foobar
+    assert_equal :baz, @subject.foobar
+  end
+
+  def test_times_called_verification
+    mock(@subject).foobar(1, 2) {:baz}
+    assert_raise RR::Expectations::TimesCalledExpectationError do
+      teardown
+    end
+  end
+end

data/examples/rspec_example_suite.rb

@@ -0,0 +1,25 @@
+require "rubygems"
+require "spec"
+
+class RspecExampleSuite
+  def run
+    options = ::Spec::Runner::OptionParser.new.parse(ARGV.dup, STDERR, STDOUT, false)
+    $behaviour_runner = options.create_behaviour_runner
+
+    require_specs
+
+    puts "Running Rspec Example Suite"
+    $behaviour_runner.run(ARGV, false)
+  end
+
+  def require_specs
+    dir = File.dirname(__FILE__)
+    Dir["#{dir}/rr/rspec/**/*_example.rb"].each do |file|
+      require file
+    end
+  end
+end
+
+if $0 == __FILE__
+  RspecExampleSuite.new.run
+end

data/examples/test_unit_example_suite.rb

@@ -0,0 +1,21 @@
+require "rubygems"
+require "spec"
+
+class TestUnitTestSuite
+  def run
+    require_tests
+
+    puts "Running Test::Unit Test Suite"
+  end
+
+  def require_tests
+    dir = File.dirname(__FILE__)
+    Dir["#{dir}/rr/test_unit/**/*_test.rb"].each do |file|
+      require file
+    end
+  end
+end
+
+if $0 == __FILE__
+  TestUnitTestSuite.new.run
+end

data/lib/rr.rb

@@ -0,0 +1,27 @@
+dir = File.dirname(__FILE__)
+
+require "rr/double"
+
+require "rr/mock_creator"
+require "rr/stub_creator"
+require "rr/probe_creator"
+require "rr/do_not_allow_creator"
+
+require "rr/scenario"
+require "rr/space"
+
+require "rr/scenario_not_found_error"
+require "rr/scenario_order_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/extensions/double_methods"

data/lib/rr/adapters/rspec.rb

@@ -0,0 +1,19 @@
+require "spec/mocks"
+require "rr"
+
+module RR
+  module Adapters
+    module Rspec
+      include RR::Extensions::DoubleMethods
+      def setup_mocks_for_rspec
+        RR::Space.instance.reset_doubles
+      end
+      def verify_mocks_for_rspec
+        RR::Space.instance.verify_doubles
+      end
+      def teardown_mocks_for_rspec
+        RR::Space.instance.reset_doubles
+      end
+    end
+  end
+end

data/lib/rr/adapters/test_unit.rb

@@ -0,0 +1,27 @@
+require "spec/mocks"
+require "rr"
+
+module RR
+  module Adapters
+    module TestUnit
+      include RR::Extensions::DoubleMethods
+      def self.included(mod)
+        mod.class_eval do
+          alias_method :setup_without_rr, :setup
+          def setup_with_rr
+            setup_without_rr
+            RR::Space.instance.reset_doubles
+          end
+          alias_method :setup, :setup_with_rr
+
+          alias_method :teardown_without_rr, :teardown
+          def teardown_with_rr
+            RR::Space.instance.verify_doubles
+            teardown_without_rr
+          end
+          alias_method :teardown, :teardown_with_rr
+        end
+      end
+    end
+  end
+end

data/lib/rr/do_not_allow_creator.rb

@@ -0,0 +1,39 @@
+module RR
+  # RR::DoNotAllowCreator uses RR::DoNotAllowCreator#method_missing to create
+  # a Scenario that expects never to be called.
+  #
+  # The following example mocks method_name with arg1 and arg2
+  # returning return_value.
+  #
+  #   do_not_allow(subject).method_name(arg1, arg2) { return_value }
+  #
+  # The DoNotAllowCreator also supports a block sytnax.
+  #
+  #    do_not_allow(subject) do |m|
+  #      m.method1 # Do not allow method1 with any arguments
+  #      m.method2(arg1, arg2) # Do not allow method2 with arguments arg1 and arg2
+  #      m.method3.with_no_args # Do not allow method3 with no arguments
+  #    end
+  class DoNotAllowCreator
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+    
+    def initialize(space, subject)
+      @space = space
+      @subject = subject
+      yield(self) if block_given?
+    end
+
+    protected
+    def method_missing(method_name, *args, &returns)
+      double = @space.create_double(@subject, method_name)
+      scenario = @space.create_scenario(double)
+      if args.empty?
+        scenario.with_any_args
+      else
+        scenario.with(*args)
+      end
+      scenario.never.returns(&returns)
+      scenario
+    end
+  end
+end

data/lib/rr/double.rb

@@ -0,0 +1,91 @@
+module RR
+  # RR::Double is the binding of an object and a method.
+  # A double has 0 to many Scenario objects. Each Scenario
+  # has Argument Expectations and Times called Expectations.
+  class Double
+    MethodArguments = Struct.new(:arguments, :block)
+    attr_reader :space, :object, :method_name, :original_method, :scenarios
+
+    def initialize(space, object, method_name)
+      @space = space
+      @object = object
+      @method_name = method_name.to_sym
+      @original_method = object.method(method_name) if @object.methods.include?(method_name.to_s)
+      @scenarios = []
+    end
+
+    # RR::Double#register_scenario adds the passed in Scenario
+    # into this Double's list of Scenario objects.
+    def register_scenario(scenario)
+      @scenarios << scenario
+    end
+
+    # RR::Double#bind injects a method that acts as a dispatcher
+    # that dispatches to the matching Scenario when the method
+    # is called.    
+    def bind
+      define_implementation_placeholder
+      returns_method = <<-METHOD
+        def #{@method_name}(*args, &block)
+          arguments = MethodArguments.new(args, block)
+          #{placeholder_name}(arguments)
+        end
+      METHOD
+      meta.class_eval(returns_method, __FILE__, __LINE__ - 5)
+    end
+
+    # RR::Double#verify verifies each Scenario
+    # TimesCalledExpectation are met.
+    def verify
+      @scenarios.each do |scenario|
+        scenario.verify
+      end
+    end
+
+    # RR::Double#reset removes the injected dispatcher method.
+    # It binds the original method implementation on the object
+    # if one exists. 
+    def reset
+      meta.send(:remove_method, placeholder_name)
+      if @original_method
+        meta.send(:define_method, @method_name, &@original_method)
+      else
+        meta.send(:remove_method, @method_name)
+      end
+    end
+
+    protected
+    def define_implementation_placeholder
+      me = self
+      meta.send(:define_method, placeholder_name) do |arguments|
+        me.send(:call_method, arguments.arguments, arguments.block)
+      end
+    end
+
+    def call_method(args, block)
+      matching_scenarios = []
+      @scenarios.each do |scenario|
+        if scenario.exact_match?(*args)
+          matching_scenarios << scenario
+          return scenario.call(*args, &block) unless scenario.times_called_verified?
+        end
+      end
+      @scenarios.each do |scenario|
+        if scenario.wildcard_match?(*args)
+          matching_scenarios << scenario
+          return scenario.call(*args, &block) unless scenario.times_called_verified?
+        end
+      end
+      matching_scenarios.first.call(*args) unless matching_scenarios.empty?
+      raise ScenarioNotFoundError, "No scenario for arguments #{args.inspect}"
+    end
+    
+    def placeholder_name
+      "__rr__#{@method_name}__rr__"
+    end
+    
+    def meta
+      (class << @object; self; end)
+    end
+  end
+end

data/lib/rr/expectations/any_argument_expectation.rb

@@ -0,0 +1,17 @@
+module RR
+  module Expectations
+    class AnyArgumentExpectation
+      def exact_match?(*arguments)
+        false
+      end
+
+      def wildcard_match?(*arguments)
+        true
+      end
+
+      def ==(other)
+        self.class == other.class
+      end
+    end
+  end
+end

data/lib/rr/expectations/argument_equality_expectation.rb

@@ -0,0 +1,35 @@
+module RR
+  module Expectations
+    class ArgumentEqualityExpectationError < RuntimeError
+    end
+    
+    class ArgumentEqualityExpectation
+      attr_reader :expected_arguments
+
+      def initialize(*expected_arguments)
+        @expected_arguments = expected_arguments
+      end
+
+      def exact_match?(*arguments)
+        @expected_arguments == arguments
+      end
+
+      def wildcard_match?(*arguments)
+        return false unless arguments.length == @expected_arguments.length
+        arguments.each_with_index do |arg, index|
+          expected_argument = @expected_arguments[index]
+          if expected_argument.respond_to?(:wildcard_match?)
+            return false unless expected_argument.wildcard_match?(arg)
+          else
+            return false unless expected_argument == arg
+          end
+        end
+        return true
+      end
+
+      def ==(other)
+        @expected_arguments == other.expected_arguments
+      end
+    end
+  end
+end

data/lib/rr/expectations/times_called_expectation.rb

@@ -0,0 +1,39 @@
+module RR
+  module Expectations
+    class TimesCalledExpectationError < RuntimeError
+    end
+    
+    class TimesCalledExpectation
+      attr_reader :times, :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
+        @times_called = 0
+      end
+
+      def verify_input
+        @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
+        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
+      end
+
+      def verify!
+        raise TimesCalledExpectationError unless verify
+      end
+
+      protected
+      def verify_input_error
+        raise TimesCalledExpectationError, "Called #{@times_called.inspect} times. Expected #{@times.inspect}"
+      end
+    end
+  end
+end