rr 1.0.5 → 1.1.0.rc1

data/spec/suites/common/test_unit_tests.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../adapter_tests', __FILE__)
+
+module TestUnitTests
+  def self.included(base)
+    base.class_eval { include AdapterTests }
+  end
+
+  def test_using_assert_received
+    subject = Object.new
+    stub(subject).foobar(1, 2)
+    subject.foobar(1, 2)
+    assert_received(subject) {|s| s.foobar(1, 2) }
+
+    error_class = RR::Errors.error_class(
+      RR::Errors::SpyVerificationErrors::InvocationCountError
+    )
+    assert_raise(error_class) do
+      assert_received(subject) {|s| s.foobar(1, 2, 3) }
+    end
+  end
+
+  def test_trim_backtrace_is_set
+    assert RR.trim_backtrace
+  end
+end

data/spec/suites/minitest/integration/minitest_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path('../../../common/test_unit_tests', __FILE__)
+
+class MiniTestIntegrationTest < MiniTest::Unit::TestCase
+  # Test::Unit compatibility
+  alias_method :assert_raise, :assert_raises
+
+  include TestUnitTests
+
+  def test_backtrace_tweaking
+    skip "test this later"
+  end
+end

data/spec/suites/minitest/test_helper.rb

@@ -0,0 +1,3 @@
+require 'minitest/autorun'
+
+require File.expand_path('../../../global_helper', __FILE__)

data/spec/suites/rspec_1/integration/rspec_1_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../common/adapter_tests', __FILE__)
+
+describe 'Integration with RSpec 1' do
+  include AdapterTests
+
+  def assert_equal(expected, actual)
+    actual.should be == expected
+  end
+
+  def assert_raise(error, message=nil, &block)
+    expect(&block).to raise_error(error, message)
+  end
+
+  instance_methods.each do |method_name|
+    if method_name =~ /^test_(.+)$/
+      it(method_name) { __send__(method_name) }
+    end
+  end
+end

data/spec/suites/rspec_1/integration/test_unit_1_rails_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../common/rails_integration_test', __FILE__)
+
+describe 'Integration between TestUnit and Rails' do
+  include IntegrationWithRails
+
+  def bootstrap
+    <<-EOT
+      RAILS_ROOT = File.expand_path(__FILE__)
+      require 'test/unit'
+
+      require 'rubygems'
+      require 'rack'
+      require 'active_support/all'
+      require 'action_controller'
+      require 'active_support/test_case'
+    EOT
+  end
+end

data/spec/suites/rspec_1/integration/test_unit_2_rails_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../common/rails_integration_test', __FILE__)
+
+describe 'Integration between TestUnit and Rails' do
+  include IntegrationWithRails
+
+  def bootstrap
+    <<-EOT
+      RAILS_ROOT = File.expand_path(__FILE__)
+      require 'rubygems'
+      require 'rack'
+      require 'test/unit'
+      require 'active_support/all'
+      require 'action_controller'
+      require 'active_support/test_case'
+    EOT
+  end
+end

data/spec/suites/rspec_1/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'spec/autorun'
+
+require File.expand_path('../../../global_helper', __FILE__)
+
+module ExampleMethods
+  def eigen(object)
+    class << object; self; end
+  end
+end
+
+module ExampleGroupMethods
+  def macro(name, &implementation)
+    (class << self; self; end).class_eval do
+      define_method(name, &implementation)
+    end
+  end
+end
+
+Spec::Runner.configure do |c|
+  c.include ExampleMethods
+  c.extend ExampleGroupMethods
+end
+
+Dir[ File.expand_path('../shared/*.rb', __FILE__) ].each {|fn| require fn }

data/spec/suites/rspec_2/functional/any_instance_of_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe '#any_instance_of' do
+  context "when passed a block" do
+    it "applies to instances instantiated before the Double expectation was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      class_called = false
+      any_instance_of(subject_class) do |o|
+        stub(o).to_s {"Subject is stubbed"}
+        stub.proxy(o).class {|klass| class_called = true; klass}
+        stub(o).foobar {:baz}
+      end
+
+      expect(subject.to_s).to eq "Subject is stubbed"
+      expect(subject.class).to eq subject_class
+      expect(class_called).to eq true
+      expect(subject.foobar).to eq :baz
+
+      RR.reset
+
+      expect(subject.to_s).to_not eq "Subject is stubbed"
+      class_called = false
+      expect(subject.class).to eq subject_class
+      expect(class_called).to eq false
+      expect(subject).to_not respond_to(:baz)
+    end
+  end
+
+  context "when passed a Hash" do
+    it "stubs methods (key) with the value on instances instantiated before the Double expectation was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      expect(subject).to_not respond_to(:baz)
+
+      any_instance_of(subject_class, :to_s => "Subject is stubbed", :foobar => lambda {:baz})
+
+      expect(subject.to_s).to eq "Subject is stubbed"
+      expect(subject.foobar).to eq :baz
+
+      RR.reset
+
+      expect(subject.to_s).to_not eq "Subject is stubbed"
+      expect(subject).to_not respond_to(:baz)
+    end
+  end
+end

data/spec/suites/rspec_2/functional/dont_allow_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe '#dont_allow' do
+  subject { Object.new }
+
+  it "raises a TimesCalledError if the method is actually called" do
+    dont_allow(subject).foobar
+    expect {
+      subject.foobar
+    }.to raise_error(RR::Errors::TimesCalledError)
+  end
+end

data/spec/suites/rspec_2/functional/dsl_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'spies' do
+  it "validates that a Double was called after it was called" do
+    stub(subject).foobar
+    subject.foobar(1, 2)
+
+    expect(subject).to have_received.foobar(1, 2)
+    expect {
+      expect(subject).to have_received.foobar(1, 2, 3)
+    }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+  end
+end

data/spec/suites/rspec_2/functional/instance_of_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+%w(instance_of all_instances_of).each do |method|
+  describe "##{method}" do
+    it "applies to instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      __send__(method, subject_class) do |o|
+        o.to_s {"Subject is stubbed"}
+      end
+      expect(subject.to_s).to eq "Subject is stubbed"
+    end
+  end
+end

data/spec/suites/rspec_2/functional/mock_spec.rb

@@ -0,0 +1,241 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe '#mock' do
+  subject { Object.new }
+
+  it "creates a mock DoubleInjection Double" do
+    mock(subject).foobar(1, 2) {:baz}
+    expect(subject.foobar(1, 2)).to eq :baz
+  end
+
+  it "mocks via inline call" do
+    mock(subject).to_s {"a value"}
+    expect(subject.to_s).to eq "a value"
+    expect { subject.to_s }.to raise_error(RR::Errors::TimesCalledError)
+    RR.reset
+  end
+
+  describe ".once.ordered" do
+    it "returns the values in the ordered called" do
+      mock(subject).to_s {"value 1"}.ordered
+      mock(subject).to_s {"value 2"}.twice
+      expect(subject.to_s).to eq "value 1"
+      expect(subject.to_s).to eq "value 2"
+      expect(subject.to_s).to eq "value 2"
+      expect { subject.to_s }.to raise_error(RR::Errors::TimesCalledError)
+      RR.reset
+    end
+  end
+
+  context "when the subject is a proxy for the object with the defined method" do
+    it "stubs the method on the proxy object" do
+      proxy_target = Class.new {def foobar; :original_foobar; end}.new
+      proxy = Class.new do
+        def initialize(target)
+          @target = target
+        end
+
+        instance_methods.each do |m|
+          unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'method_missing'
+            alias_method "__blank_slated_#{m}", m
+            undef_method m
+          end
+        end
+
+        def method_missing(method_name, *args, &block)
+          @target.send(method_name, *args, &block)
+        end
+      end.new(proxy_target)
+      expect(proxy.methods).to match_array(proxy_target.methods)
+
+      mock(proxy).foobar {:new_foobar}
+      expect(proxy.foobar).to eq :new_foobar
+    end
+  end
+
+  it 'allows terse chaining' do
+    mock(subject).first(1) {mock(Object.new).second(2) {mock(Object.new).third(3) {4}}}
+    expect(subject.first(1).second(2).third(3)).to eq 4
+
+    mock(subject).first(1) {mock!.second(2) {mock!.third(3) {4}}}
+    expect(subject.first(1).second(2).third(3)).to eq 4
+
+    mock(subject).first(1) {mock!.second(2).mock!.third(3) {4}}
+    expect(subject.first(1).second(2).third(3)).to eq 4
+
+    mock(subject).first(1) {mock!.second(2).mock! {third(3) {4}}}
+    expect(subject.first(1).second(2).third(3)).to eq 4
+
+    mock(subject).first(1).mock!.second(2).mock!.third(3) {4}
+    expect(subject.first(1).second(2).third(3)).to eq 4
+  end
+
+  it 'allows chaining with proxy' do
+    pending "this is failing with a TimesCalledError"
+
+    find_return_value = Object.new
+    def find_return_value.child
+      :the_child
+    end
+    (class << subject; self; end).class_eval do
+      define_method(:find) do |id|
+        id == '1' ? find_return_value : raise(ArgumentError)
+      end
+    end
+
+    mock.proxy(subject).find('1').mock.proxy!.child
+    expect(subject.find('1').child).to eq :the_child
+  end
+
+  it 'allows branched chaining' do
+    mock(subject).first do
+      mock! do |expect|
+        expect.branch1 {mock!.branch11 {11}}
+        expect.branch2 {mock!.branch22 {22}}
+      end
+    end
+    o = subject.first
+    expect(o.branch1.branch11).to eq 11
+    expect(o.branch2.branch22).to eq 22
+  end
+
+  it 'allows chained ordering' do
+    mock(subject).to_s {"value 1"}.then.to_s {"value 2"}.twice.then.to_s {"value 3"}.once
+    expect(subject.to_s).to eq "value 1"
+    expect(subject.to_s).to eq "value 2"
+    expect(subject.to_s).to eq "value 2"
+    expect(subject.to_s).to eq "value 3"
+    expect { subject.to_s }.to raise_error(RR::Errors::TimesCalledError)
+    RR.reset
+  end
+
+  it "mocks via block with argument" do
+    mock subject do |c|
+      c.to_s {"a value"}
+      c.to_sym {:crazy}
+    end
+    expect(subject.to_s).to eq "a value"
+    expect(subject.to_sym).to eq :crazy
+  end
+
+  it "mocks via block without argument" do
+    mock subject do
+      to_s {"a value"}
+      to_sym {:crazy}
+    end
+    expect(subject.to_s).to eq "a value"
+    expect(subject.to_sym).to eq :crazy
+  end
+
+  it "has wildcard matchers" do
+    mock(subject).foobar(
+      is_a(String),
+      anything,
+      numeric,
+      boolean,
+      duck_type(:to_s),
+      /abc/
+    ) {"value 1"}.twice
+    expect(subject.foobar(
+      'hello',
+      Object.new,
+      99,
+      false,
+      "My String",
+      "Tabcola"
+    )).to eq("value 1")
+    expect {
+      subject.foobar(:failure)
+    }.to raise_error(RR::Errors::DoubleNotFoundError)
+
+    RR.reset
+  end
+
+  it "mocks methods without letters" do
+    mock(subject, :==).with(55)
+
+    subject == 55
+    expect {
+      subject == 99
+    }.to raise_error(RR::Errors::DoubleNotFoundError)
+
+    RR.reset
+  end
+
+  it "expects a method call to a mock via another mock's block yield only once" do
+    cage = Object.new
+    cat = Object.new
+    mock(cat).miau    # should be expected to be called only once
+    mock(cage).find_cat.yields(cat)
+    mock(cage).cats
+    cage.find_cat { |c| c.miau }
+    cage.cats
+  end
+
+  describe "on class method" do
+    class SampleClass1
+      def self.hello; "hello!"; end
+    end
+
+    class SampleClass2 < SampleClass1; end
+
+    it "can mock" do
+      mock(SampleClass1).hello { "hola!" }
+
+      expect(SampleClass1.hello).to eq "hola!"
+    end
+
+    it "does not override subclasses" do
+      mock(SampleClass1).hello { "hi!" }
+      SampleClass1.hello
+      expect(SampleClass2.hello).to eq "hello!"
+    end
+
+    it "should not get affected from a previous example" do
+      expect(SampleClass2.hello).to eq "hello!"
+    end
+  end
+
+  # bug #44
+  describe 'when wrapped in an array that is then flattened' do
+    context 'when the method being mocked is not defined' do
+      it "does not raise an error" do
+        mock(subject).foo
+        subject.foo
+        expect([subject].flatten).to eq [subject]
+      end
+
+      it "honors a #to_ary that already exists" do
+        subject.instance_eval do
+          def to_ary; []; end
+        end
+        mock(subject).foo
+        subject.foo
+        expect([subject].flatten).to eq []
+      end
+    end
+
+    context 'when the method being mocked is defined' do
+      before do
+        subject.instance_eval do
+          def foo; end
+        end
+      end
+
+      it "does not raise an error" do
+        mock(subject).foo
+        subject.foo
+        expect([subject].flatten).to eq [subject]
+      end
+
+      it "honors a #to_ary that already exists" do
+        eigen(subject).class_eval do
+          def to_ary; []; end
+        end
+        mock(subject).foo
+        subject.foo
+        expect([subject].flatten).to eq []
+      end
+    end
+  end
+end