rr 1.1.1 → 1.1.2.rc1

data/spec/suites/rspec_1_rails_2/integration/test_unit_2_rails_2_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'Integration with Test::Unit ~> 2.4 and Rails 2' do
+  include IntegrationTests::RailsTestUnit
+
+  def configure_rails_project_generator(project_generator)
+    super
+    project_generator.configure do |project|
+      project.rails_version = 2
+    end
+  end
+
+  def configure_project_generator(project_generator)
+    super
+    project_generator.configure do |project|
+      project.test_unit_gem_version = '~> 2.4'
+    end
+  end
+
+  def self.including_the_adapter_manually_works
+    specify "including the adapter manually works" do
+      project = generate_project do |project|
+        project.add_to_prelude <<-EOT
+          class ActiveSupport::TestCase
+            include RR::Adapters::TestUnit
+          end
+        EOT
+      end
+      project.add_test_file do |file|
+        file.add_working_test_case_with_adapter_tests do |test_case|
+          test_case.add_to_body <<-EOT
+            def test_the_correct_adapters_are_loaded
+              assert_adapters_loaded #{adapters_that_should_be_loaded.inspect}
+            end
+          EOT
+        end
+      end
+      result = project.run_tests
+      result.should be_success
+      result.should_not have_errors_or_failures
+    end
+  end
+
+  def self.rr_hooks_into_the_test_framework_automatically
+    specify "RR hooks into the test framework automatically" do
+      project = generate_project
+      project.add_test_file do |file|
+        file.add_working_test_case
+      end
+      result = project.run_tests
+      result.should be_success
+      result.should_not have_errors_or_failures
+    end
+  end
+
+  def self.using_rr_with_cucumber_works
+    specify "using RR with Cucumber works" do
+      project_generator = build_rails_project_generator do |project_generator|
+        project_generator.mixin Project::Cucumber
+      end
+      project = project_generator.call
+      result = project.run_command_within("cucumber")
+      result.should be_success
+    end
+  end
+
+  context 'when RR is listed in config/environment.rb' do
+    def configure_project_generator(project_generator)
+      super
+      project_generator.configure do |project|
+        project.autorequire_gems = true
+      end
+    end
+
+    def adapters_that_should_be_loaded
+      [:TestUnit2]
+    end
+
+    including_the_adapter_manually_works
+    using_rr_with_cucumber_works
+  end
+
+  context 'when RR is being required manually' do
+    def configure_project_generator(project_generator)
+      super
+      project_generator.configure do |project|
+        project.autorequire_gems = false
+      end
+    end
+
+    def adapters_that_should_be_loaded
+      [:TestUnit2, :TestUnit2ActiveSupport]
+    end
+
+    rr_hooks_into_the_test_framework_automatically
+    including_the_adapter_manually_works
+    using_rr_with_cucumber_works
+
+    specify "when RR raises an error it raises a failure not an exception" do
+      project = generate_project
+      project.add_test_file do |file|
+        file.add_test_case do |test_case|
+          test_case.add_test <<-EOT
+            object = Object.new
+            mock(object).foo
+          EOT
+        end
+      end
+      result = project.run_tests
+      result.should fail_with_output(/1 failure/)
+    end
+
+    specify "the database is properly rolled back after an RR error" do
+      project = generate_project do |project|
+        project.add_model_and_migration(:person, :people, :name => :string)
+      end
+      project.add_test_file do |file|
+        file.add_test_case do |test_case|
+          test_case.add_test <<-EOT
+            Person.create!(:name => 'Joe Blow')
+            object = Object.new
+            mock(object).foo
+          EOT
+        end
+      end
+      expect {
+        result = project.run_tests
+        result.should have_errors_or_failures
+      }.to leave_database_table_clear(project, :people)
+    end
+
+    specify "throwing an error in teardown doesn't mess things up" do
+      project = generate_project
+      project.add_test_file do |file|
+        file.add_test_case do |test_case|
+          test_case.add_to_body <<-EOT
+            def teardown
+              raise 'hell'
+            end
+          EOT
+          test_case.add_test("")   # doesn't matter
+        end
+      end
+      result = project.run_tests
+      result.should fail_with_output(/1 error/)
+    end
+  end
+end

data/spec/suites/rspec_1_rails_2/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.expand_path('../../../global_helper', __FILE__)
+RR::Test.setup_test_suite(:rspec_1_rails_2)
+require File.expand_path('../../rspec_1/helper', __FILE__)

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