rr 0.1.0

data/CHANGES

@@ -0,0 +1 @@
+* 0.1.0

data/README

@@ -0,0 +1,45 @@
+= RR
+
+RR (Double Ruby) is a double framework that features a rich
+selection of double techniques and a terse syntax.
+http://xunitpatterns.com/Test%20Double.html
+
+Currently RR implements mocks, stubs, and probes. It is a goal of
+RR to support a wide range of double techniques and patterns.
+
+== Mocking
+http://xunitpatterns.com/Mock%20Object.html
+  view = controller.template
+  mock(view).render(:partial => "user_info") {"Information"}
+
+== Stubbing
+http://xunitpatterns.com/Test%20Stub.html
+  jane = User.new
+  stub(User).find('42') {jane}
+  mock(jane).valid? {true}
+
+== Probing
+Add verifications that a method was called while actually calling it.
+The following example verifies render partial will be called and
+renders the partial.
+
+  view = controller.template
+  probe(view).render(:partial => "user_info")
+  
+== Block Syntax
+  script = MyScript.new
+  mock(script) do |m|
+    m.system("cd #{RAILS_ENV}") {true}
+    m.system("rake foo:bar") {true}
+    m.system("rake baz") {true}
+  end
+
+== Terse Syntax
+One of the goals of RR is to make doubles more scannable.
+This is accomplished by removing words from a double declaration.
+Here is RR compared to other mock frameworks:
+
+  flexmock(User).should_receive(:find).with('42').and_return(jane) # Flexmock
+  User.should_receive(:find).with('42').and_return(jane) # Rspec
+  User.expects(:find).with('42').returns {jane} # Mocha
+  mock(User).find('42') {jane} # RR

data/Rakefile

@@ -0,0 +1,60 @@
+require "rake"
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc "Runs the Rspec suite"
+task(:default) do
+  run_suite
+end
+
+desc "Runs the Rspec suite"
+task(:spec) do
+  run_suite
+end
+
+def run_suite
+  dir = File.dirname(__FILE__)
+  system("ruby #{dir}/examples/example_suite.rb") || raise("Example Suite failed")
+end
+
+PKG_NAME = "rr"
+PKG_VERSION = "0.1.0"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  '*.rb',
+  'lib/**/*.rb',
+  'examples/**/*.rb'
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "RR (Double Ruby) is a double framework that features a rich " <<
+              "selection of double techniques and a terse syntax. " <<
+              "http://xunitpatterns.com/Test%20Double.html"
+  s.test_files = "examples/example_suite.rb"
+  s.description = s.summary
+
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ "README", "CHANGES" ]
+  s.rdoc_options = ["--main", "README", "--inline-source", "--line-numbers"]
+
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.require_path = 'lib'
+  s.autorequire = 'rr'
+  s.author = "Brian Takita"
+  s.email = "brian@pivotallabs.com"
+  s.homepage = "http://pivotallabs.com"
+  s.rubyforge_project = "pivotalrb"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/examples/environment_fixture_setup.rb

@@ -0,0 +1,7 @@
+require "rubygems"
+require "spec"
+dir = File.dirname(__FILE__)
+$LOAD_PATH << "#{dir}/../lib"
+require "rr"
+require "ruby-debug"
+require "pp"

data/examples/example_helper.rb

@@ -0,0 +1,8 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/environment_fixture_setup"
+require "examples/rr/space_helper"
+
+require "rr/adapters/rspec"
+Spec::Runner.configure do |config|
+  config.mock_with RR::Adapters::Rspec
+end

data/examples/example_suite.rb

@@ -0,0 +1,45 @@
+require "rubygems"
+require "spec"
+
+class ExampleSuite
+  def run
+    options = ::Spec::Runner::OptionParser.new.parse(ARGV.dup, STDERR, STDOUT, false)
+    $behaviour_runner = options.create_behaviour_runner
+    
+    require_specs
+
+    puts "Running Example Suite"
+    $behaviour_runner.run(ARGV, false)
+
+    run_rspec_examples
+    run_test_unit_examples
+  end
+
+  def require_specs
+    exclusions = []
+    exclusions << "rspec/"
+    exclusions << "test_unit/"
+
+    Dir["#{dir}/**/*_example.rb"].each do |file|
+      unless exclusions.any? {|match| file.include?(match)}
+        require file
+      end
+    end
+  end
+
+  def run_rspec_examples
+    system("ruby #{dir}/rspec_example_suite.rb") || raise("Rspec suite Failed")
+  end
+
+  def run_test_unit_examples
+    system("ruby #{dir}/test_unit_example_suite.rb") || raise("Test::Unit suite Failed")
+  end
+
+  def dir
+    File.dirname(__FILE__)
+  end
+end
+
+if $0 == __FILE__
+  ExampleSuite.new.run
+end

data/examples/high_level_example.rb

@@ -0,0 +1,132 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/example_helper"
+
+describe "RR", :shared => true do
+  before(:each) do
+    @obj = Object.new
+    extend RR::Extensions::DoubleMethods
+  end
+
+  after(:each) do
+    RR::Space.instance.reset_doubles
+  end
+end
+
+describe "RR mock:" do
+  it_should_behave_like "RR"
+
+  it "mocks via inline call" do
+    mock(@obj).to_s {"a value"}
+    @obj.to_s.should == "a value"
+    proc {@obj.to_s}.should raise_error(RR::Expectations::TimesCalledExpectationError)
+  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"
+    proc {@obj.to_s}.should raise_error(RR::Expectations::TimesCalledExpectationError)
+  end
+
+  it "mocks via block" do
+    mock @obj do |c|
+      c.to_s {"a value"}
+      c.to_sym {:crazy}
+    end
+    @obj.to_s.should == "a value"
+    @obj.to_sym.should == :crazy
+  end
+  
+  it "has wildcard matchers" do
+    mock(@obj).foobar(
+      is_a(String),
+      anything,
+      numeric,
+      boolean,
+      duck_type(:to_s),
+      /abc/
+    ) {"value 1"}.twice
+    @obj.foobar(
+      'hello',
+      Object.new,
+      99,
+      false,
+      "My String",
+      "Tabcola"
+    ).should == "value 1"
+    proc {@obj.foobar(:failure)}.should raise_error( RR::ScenarioNotFoundError )
+  end
+end
+
+describe "RR probe:" do
+  it_should_behave_like "RR"
+
+  it "probes via inline call" do
+    expected_to_s_value = @obj.to_s
+    probe(@obj).to_s
+    @obj.to_s.should == expected_to_s_value
+    proc {@obj.to_s}.should raise_error
+  end
+
+  it "allows ordering" do
+    def @obj.to_s(arg)
+      "Original to_s with arg #{arg}"
+    end
+    probe(@obj).to_s(:foo).ordered
+    probe(@obj).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"
+    proc {@obj.to_s(:bar)}.should raise_error(RR::Expectations::TimesCalledExpectationError)
+  end
+
+  it "probes via block" do
+    def @obj.foobar_1(*args)
+      :original_value_1
+    end
+
+    def @obj.foobar_2
+      :original_value_2
+    end
+
+    probe @obj do |c|
+      c.foobar_1(1)
+      c.foobar_2
+    end
+    @obj.foobar_1(1).should == :original_value_1
+    proc {@obj.foobar_1(:blah)}.should raise_error
+
+    @obj.foobar_2.should == :original_value_2
+    proc {@obj.foobar_2(:blah)}.should raise_error
+  end
+end
+
+describe "RR stub:" do
+  it_should_behave_like "RR"
+
+  it "stubs via inline call" do
+    stub(@obj).to_s {"a value"}
+    @obj.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
+
+    @obj.to_s.should == "value 1"
+    @obj.to_s.should == "value 2"
+  end
+
+  it "stubs via block" do
+    stub @obj do |d|
+      d.to_s {"a value"}
+      d.to_sym {:crazy}
+    end
+    @obj.to_s.should == "a value"
+    @obj.to_sym.should == :crazy
+  end
+end

data/examples/rr/do_not_allow_creator_example.rb

@@ -0,0 +1,90 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../example_helper"
+
+module RR
+describe DoNotAllowCreator, :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 DoNotAllowCreator, ".new" do
+  it_should_behave_like "RR::DoNotAllowCreator"
+
+  before do
+    @creator = DoNotAllowCreator.new(@space, @subject)
+  end
+end
+
+describe DoNotAllowCreator, ".new with block" do
+  it_should_behave_like "RR::DoNotAllowCreator"
+
+  before do
+    @creator = DoNotAllowCreator.new(@space, @subject) do |c|
+      c.any_args
+      c.no_args.with_no_args
+      c.with_args(1, 2)
+    end
+  end
+
+  it "raises TimesCalledExpectationError when any_args is called with no arguments" do
+    proc {@subject.any_args}.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+
+  it "raises TimesCalledExpectationError when any_args is called with arguments" do
+    proc {@subject.any_args(1, 2)}.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+
+  it "raises TimesCalledExpectationError when no_args is called with no arguments" do
+    proc {@subject.no_args}.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+
+  it "does not raise TimesCalledExpectationError when no_args is called with arguments" do
+    proc {@subject.no_args(1, 2)}.should raise_error(ScenarioNotFoundError)
+  end
+
+  it "raises TimesCalledExpectationError when any_args is called with no arguments" do
+    proc {@subject.with_args}.should raise_error(ScenarioNotFoundError)
+  end
+
+  it "raises TimesCalledExpectationError when any_args is called with arguments" do
+    proc {@subject.any_args(1, 2)}.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+end
+
+describe DoNotAllowCreator, "#method_missing" do
+  it_should_behave_like "RR::DoNotAllowCreator"
+
+  before do
+    @subject = Object.new
+    @creator = DoNotAllowCreator.new(@space, @subject)
+  end
+
+  it "sets expectation for method to never be called with any arguments when on arguments passed in" do
+    @creator.foobar
+    proc {@subject.foobar}.should raise_error(Expectations::TimesCalledExpectationError)
+    proc {@subject.foobar(1, 2)}.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+
+  it "sets expectation for method to never be called with passed in arguments" do
+    @creator.foobar(1, 2)
+    proc {@subject.foobar}.should raise_error(ScenarioNotFoundError)
+    proc {@subject.foobar(1, 2)}.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+
+  it "sets expectation for method to never be called with no arguments when with_no_args is set" do
+    @creator.foobar.with_no_args
+    proc {@subject.foobar}.should raise_error(Expectations::TimesCalledExpectationError)
+    proc {@subject.foobar(1, 2)}.should raise_error(ScenarioNotFoundError)
+  end
+end
+
+end

data/examples/rr/double_bind_example.rb

@@ -0,0 +1,32 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../example_helper"
+
+module RR
+describe Double, "#bind with an existing method" do
+  before do
+    @space = Space.new
+    @object = Object.new
+    @method_name = :foobar
+    def @object.foobar; :original_foobar; end
+    @object.methods.should include(@method_name.to_s)
+    @double = Double.new(@space, @object, @method_name)
+  end
+
+  it "overrides the original method with the double's dispatching methods" do
+    @object.respond_to?(:__rr__foobar__rr__).should == false
+    @double.bind
+    @object.respond_to?(:__rr__foobar__rr__).should == true
+
+    rr_foobar_called = false
+    (class << @object; self; end).class_eval do
+      define_method :__rr__foobar__rr__ do
+        rr_foobar_called = true
+      end
+    end
+
+    rr_foobar_called.should == false
+    @object.foobar
+    rr_foobar_called.should == true
+  end
+end
+end

data/examples/rr/double_dispatching_example.rb

@@ -0,0 +1,167 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../example_helper"
+
+module RR
+describe Double, "method dispatching", :shared => true do
+  before do
+    @space = Space.new
+    @object = Object.new
+    @method_name = :foobar
+    @object.methods.should_not include(@method_name.to_s)
+    @double = @space.create_double(@object, @method_name)
+  end
+end
+
+describe Double, " method dispatching where the scenario takes a block" do
+  it_should_behave_like "RR::Double method dispatching"
+
+  it "executes the block" do
+    method_fixture = Object.new
+     class << method_fixture
+      def method_with_block(a, b)
+        yield(a,b)
+      end
+    end
+    scenario = @space.create_scenario(@double)
+    scenario.with(1, 2).implemented_by(method_fixture.method(:method_with_block))
+    @object.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
+  end
+end
+
+describe Double, " method dispatching where there are no scenarios with duplicate ArgumentExpectations" do
+  it_should_behave_like "RR::Double method dispatching"
+
+  it "dispatches to Scenario that have an exact match" do
+    scenario1_with_exact_match = @space.create_scenario(@double)
+    scenario1_with_exact_match.with(:exact_match_1).returns {:return_1}
+    scenario_with_no_match = @space.create_scenario(@double)
+    scenario_with_no_match.with("nothing that matches").returns {:no_match}
+    scenario2_with_exact_match = @space.create_scenario(@double)
+    scenario2_with_exact_match.with(:exact_match_2).returns {:return_2}
+
+    @object.foobar(:exact_match_1).should == :return_1
+    @object.foobar(:exact_match_2).should == :return_2
+  end
+
+  it "dispatches to Scenario that have a wildcard match" do
+    scenario_with_wildcard_match = @space.create_scenario(@double)
+    scenario_with_wildcard_match.with_any_args.returns {:wild_card_value}
+    scenario_with_no_match = @space.create_scenario(@double)
+    scenario_with_no_match.with("nothing that matches").returns {:no_match}
+
+    @object.foobar(:wildcard_match_1).should == :wild_card_value
+    @object.foobar(:wildcard_match_2, 3).should == :wild_card_value
+  end
+end
+
+describe Double, " method dispatching where there are scenarios" do
+  it_should_behave_like "RR::Double method dispatching"
+
+  it "raises ScenarioNotFoundError error when arguments do not match a scenario" do
+    scenario_1 = @space.create_scenario(@double)
+    scenario_1.with(1, 2)
+
+    scenario_2 = @space.create_scenario(@double)
+    scenario_2.with(3)
+
+    proc {@object.foobar(:no_matching_args)}.should raise_error(
+      ScenarioNotFoundError,
+      "No scenario for arguments [:no_matching_args]"
+    )
+  end
+end
+
+describe Double, " method dispatching where there are scenarios with duplicate Exact Match ArgumentExpectations" do
+  it_should_behave_like "RR::Double method dispatching"
+
+  it "dispatches to Scenario that have an exact match" do
+    scenario1_with_exact_match = @space.create_scenario(@double)
+    scenario1_with_exact_match.with(:exact_match).returns {:return_1}
+
+    @object.foobar(:exact_match).should == :return_1
+  end
+
+  it "dispatches to the first Scenario that have an exact match" do
+    scenario1_with_exact_match = @space.create_scenario(@double)
+    scenario1_with_exact_match.with(:exact_match).returns {:return_1}
+
+    scenario2_with_exact_match = @space.create_scenario(@double)
+    scenario2_with_exact_match.with(:exact_match).returns {:return_2}
+
+    @object.foobar(:exact_match).should == :return_1
+  end
+
+  it "dispatches the second Scenario with an exact match
+      when the first scenario's Times Called expectation is satisfied" do
+    scenario1_with_exact_match = @space.create_scenario(@double)
+    scenario1_with_exact_match.with(:exact_match).returns {:return_1}.once
+
+    scenario2_with_exact_match = @space.create_scenario(@double)
+    scenario2_with_exact_match.with(:exact_match).returns {:return_2}.once
+
+    @object.foobar(:exact_match)
+    @object.foobar(:exact_match).should == :return_2
+  end
+
+  it "raises TimesCalledExpectationError when all of the scenarios Times Called expectation is satisfied" do
+    scenario1_with_exact_match = @space.create_scenario(@double)
+    scenario1_with_exact_match.with(:exact_match).returns {:return_1}.once
+
+    scenario2_with_exact_match = @space.create_scenario(@double)
+    scenario2_with_exact_match.with(:exact_match).returns {:return_2}.once
+
+    @object.foobar(:exact_match)
+    @object.foobar(:exact_match)
+    proc do
+      @object.foobar(:exact_match)
+    end.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+end
+
+describe Double, " method dispatching where there are scenarios with duplicate Wildcard Match ArgumentExpectations" do
+  it_should_behave_like "RR::Double method dispatching"
+
+  it "dispatches to Scenario that have a wildcard match" do
+    scenario_1 = @space.create_scenario(@double)
+    scenario_1.with_any_args.returns {:return_1}
+
+    @object.foobar(:anything).should == :return_1
+  end
+
+  it "dispatches to the first Scenario that has a wildcard match" do
+    scenario_1 = @space.create_scenario(@double)
+    scenario_1.with_any_args.returns {:return_1}
+
+    scenario_2 = @space.create_scenario(@double)
+    scenario_2.with_any_args.returns {:return_2}
+
+    @object.foobar(:anything).should == :return_1
+  end
+
+  it "dispatches the second Scenario with a wildcard match
+      when the first scenario's Times Called expectation is satisfied" do
+    scenario_1 = @space.create_scenario(@double)
+    scenario_1.with_any_args.returns {:return_1}.once
+
+    scenario_2 = @space.create_scenario(@double)
+    scenario_2.with_any_args.returns {:return_2}.once
+
+    @object.foobar(:anything)
+    @object.foobar(:anything).should == :return_2
+  end
+
+  it "raises TimesCalledExpectationError when all of the scenarios Times Called expectation is satisfied" do
+    scenario_1 = @space.create_scenario(@double)
+    scenario_1.with_any_args.returns {:return_1}.once
+
+    scenario_2 = @space.create_scenario(@double)
+    scenario_2.with_any_args.returns {:return_2}.once
+
+    @object.foobar(:anything)
+    @object.foobar(:anything)
+    proc do
+      @object.foobar(:anything)
+    end.should raise_error(Expectations::TimesCalledExpectationError)
+  end
+end
+end