rr 1.1.2 → 3.0.2

data/spec/global_helper.rb

@@ -30,4 +30,9 @@ module RR
   end
 end
 
+lib_path = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
 Dir[ File.expand_path('../support/**/*.rb', __FILE__) ].each { |fn| require fn }
+
+$stdout.sync = true

data/spec/spec_suite_configuration.rb

@@ -26,18 +26,12 @@ class SpecSuiteConfiguration
     end
 
     def current_ruby_id
-      ruby_18? ? '18' : '19'
+      '19'
     end
 
     def matching_current_ruby_version?
       ruby_id == current_ruby_id
     end
-
-    private
-
-    def ruby_18?
-      RUBY_VERSION =~ /^1\.8/
-    end
   end
 
   attr_reader :ruby_groups, :runners

data/spec/suites.yml

@@ -1,13 +1,3 @@
-18:
-  rvm_versions:
-    - name: 1.8.7
-  suites:
-    - name: rspec_1
-      desc: 'RSpec 1'
-    - name: rspec_1_rails_2
-      desc: 'RSpec 1 + Rails 2'
-  env:
-    SPEC_OPTS: '--require $PWD/spec/custom_formatter_for_rspec --format CustomFormatterForRSpec --backtrace'
 19:
   rvm_versions:
     - name: 1.9.3
@@ -16,9 +6,5 @@
   suites:
     - name: rspec_2
       desc: 'RSpec 2'
-    - name: rspec_2_rails_3
-      desc: 'RSpec 2 + Rails 3'
-    - name: rspec_2_rails_4
-      desc: 'RSpec 2 + Rails 4'
   env:
     SPEC_OPTS: '--require $PWD/spec/custom_formatter_for_rspec_2 --format CustomFormatterForRSpec2 --backtrace'

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

@@ -1,47 +1,147 @@
 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
+describe 'any_instance_of' do
+  context 'stubs for instance methods of a class' do
+    context 'via block form' do
+      context 'for existing methods' do
+        it "can be defined" do
+          a_class = Class.new { def some_method; 'value'; end }
+          any_instance_of(a_class) { |c| stub(c).some_method { 'value' } }
+          instance = a_class.new
+          expect(instance.some_method).to eq 'value'
+        end
 
-      RR.reset
+        it "can be reset" do
+          a_class = Class.new { def some_method; 'original value'; end }
+          any_instance_of(a_class) { |c| stub(c).some_method { 'value' } }
+          RR.reset
+          instance = a_class.new
+          expect(instance.some_method).to eq 'original value'
+        end
+      end
 
-      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)
+      context 'for non-existing methods' do
+        it "can be defined" do
+          a_class = Class.new
+          any_instance_of(a_class) { |c| stub(c).some_method { 'value' } }
+          instance = a_class.new
+          expect(instance.some_method).to eq 'value'
+        end
+
+        it "can be reset" do
+          a_class = Class.new
+          any_instance_of(a_class) { |c| stub(c).some_method { 'value' } }
+          RR.reset
+          instance = a_class.new
+          expect(instance).not_to respond_to(:some_method)
+        end
+      end
     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)
+    context 'via hash form' do
+      context 'for existing methods' do
+        it "can be defined" do
+          a_class = Class.new { def some_method; 'value'; end }
+          any_instance_of(a_class, :some_method => lambda { 'value' })
+          instance = a_class.new
+          expect(instance.some_method).to eq 'value'
+        end
+
+        it "can be reset" do
+          a_class = Class.new { def some_method; 'original value'; end }
+          any_instance_of(a_class, :some_method => lambda { 'value' })
+          RR.reset
+          instance = a_class.new
+          expect(instance.some_method).to eq 'original value'
+        end
+      end
+
+      context 'for non-existing methods' do
+        it "can be defined" do
+          a_class = Class.new
+          any_instance_of(a_class, :some_method => lambda { 'value' })
+          instance = a_class.new
+          expect(instance.some_method).to eq 'value'
+        end
 
-      any_instance_of(subject_class, :to_s => "Subject is stubbed", :foobar => lambda {:baz})
+        it "can be reset" do
+          a_class = Class.new
+          any_instance_of(a_class, :some_method => lambda { 'value' })
+          RR.reset
+          instance = a_class.new
+          expect(instance).not_to respond_to(:some_method)
+        end
+      end
+    end
+  end
 
-      expect(subject.to_s).to eq "Subject is stubbed"
-      expect(subject.foobar).to eq :baz
+  context 'stub-proxies for instance methods of a class' do
+    it "can be defined" do
+      a_class = Class.new { def some_method; 'value'; end }
+      any_instance_of(a_class) { |c| stub.proxy(c).some_method { 'value' } }
+      instance = a_class.new
+      expect(instance.some_method).to eq 'value'
+    end
 
+    it "can be reset" do
+      a_class = Class.new { def some_method; 'original value'; end }
+      any_instance_of(a_class) { |c| stub.proxy(c).some_method { 'value' } }
       RR.reset
+      instance = a_class.new
+      expect(instance.some_method).to eq 'original value'
+    end
+  end
 
-      expect(subject.to_s).to_not eq "Subject is stubbed"
-      expect(subject).to_not respond_to(:baz)
+  context 'mocks for instance methods of a class' do
+    context 'for existing methods' do
+      it "can be defined" do
+        a_class = Class.new { def some_method; 'value'; end }
+        any_instance_of(a_class) { |c| mock(c).some_method { 'value' } }
+        instance = a_class.new
+        expect(instance.some_method).to eq 'value'
+      end
+
+      it "can be reset" do
+        a_class = Class.new { def some_method; 'original value'; end }
+        any_instance_of(a_class) { |c| mock(c).some_method { 'value' } }
+        RR.reset
+        instance = a_class.new
+        expect(instance.some_method).to eq 'original value'
+      end
+    end
+
+    context 'for non-existing methods' do
+      it "can be defined" do
+        a_class = Class.new
+        any_instance_of(a_class) { |c| mock(c).some_method { 'value' } }
+        instance = a_class.new
+        expect(instance.some_method).to eq 'value'
+      end
+
+      it "can be reset" do
+        a_class = Class.new
+        any_instance_of(a_class) { |c| mock(c).some_method { 'value' } }
+        RR.reset
+        instance = a_class.new
+        expect(instance).not_to respond_to(:some_method)
+      end
+    end
+  end
+
+  context 'mock-proxies for instance methods of a class' do
+    it "can be defined" do
+      a_class = Class.new { def some_method; 'value'; end }
+      any_instance_of(a_class) { |c| mock.proxy(c).some_method { 'value' } }
+      instance = a_class.new
+      expect(instance.some_method).to eq 'value'
+    end
+
+    it "can be reset" do
+      a_class = Class.new { def some_method; 'original value'; end }
+      any_instance_of(a_class) { |c| mock.proxy(c).some_method { 'value' } }
+      RR.reset
+      instance = a_class.new
+      expect(instance.some_method).to eq 'original value'
     end
   end
 end

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

@@ -1,12 +1,17 @@
 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)
+describe 'dont_allow', is_mock: true, is_dont_allow: true do
+  include MockDefinitionCreatorHelpers
+
+  context 'against instance methods', method_type: :instance do
+    include_context 'tests for a double definition creator method that supports dont_allow'
+  end
+
+  context 'against class methods', method_type: :class do
+    include_context 'tests for a double definition creator method that supports dont_allow'
+  end
+
+  def double_definition_creator_for(object, &block)
+    dont_allow(object, &block)
   end
 end

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

@@ -0,0 +1,20 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'mock!' do
+  it "is a terser way of creating an object and mocking it" do
+    object = mock!.some_method { 'value' }.subject
+    expect(object.some_method).to eq 'value'
+  end
+
+  it "can be used inside the implementation block of a double" do
+    object = Object.new
+    stub(object).some_method { mock!.another_method { 'value' } }
+    expect(object.some_method.another_method).to eq 'value'
+  end
+
+  it "can be called on a double" do
+    object = Object.new
+    stub(object).some_method.mock!.another_method { 'value' }
+    expect(object.some_method.another_method).to eq 'value'
+  end
+end

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

@@ -0,0 +1,14 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  %w(mock instance_of).permutation.map { |parts| parts.join('.') }
+
+permutations.each do |permutation|
+  describe permutation, is_mock: true, is_instance_of: true do
+    include_context 'mock + instance_of'
+
+    define_method(:double_definition_creator_for) do |object, &block|
+      eval(permutation + '(object, &block)')
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  %w(mock instance_of strong).permutation.to_a.
+  map { |parts| parts.join('.') }
+
+permutations.each do |permutation|
+  describe permutation, is_mock: true, is_instance_of: true, is_strong: true do
+    include_context 'mock + instance_of + strong'
+
+    define_method(:double_definition_creator_for) do |object, &block|
+      eval(permutation + '(object, &block)')
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  %w(mock proxy instance_of).permutation.map { |parts| parts.join('.') }
+
+permutations.each do |permutation|
+  describe permutation, is_mock: true, is_proxy: true, is_instance_of: true do
+    include_context 'mock + instance_of'
+    include ProxyDefinitionCreatorHelpers
+
+    define_method(:double_definition_creator_for) do |object, &block|
+      eval(permutation + '(object, &block)')
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  %w(mock proxy).permutation.map { |parts| parts.join('.') }
+
+permutations.each do |permutation|
+  describe permutation, is_mock: true, is_proxy: true do
+    include_context 'mock + proxy'
+
+    define_method(:double_definition_creator_for) do |object, &block|
+      eval(permutation + '(object, &block)')
+    end
+  end
+end

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

@@ -1,241 +1,17 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe '#mock' do
-  subject { Object.new }
+describe 'mock', is_mock: true do
+  include MockDefinitionCreatorHelpers
 
-  it "creates a mock DoubleInjection Double" do
-    mock(subject).foobar(1, 2) {:baz}
-    expect(subject.foobar(1, 2)).to eq :baz
+  context 'against instance methods', method_type: :instance do
+    include_context 'tests for a double definition creator method that supports mocking'
   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
+  context 'against class methods', method_type: :class do
+    include_context 'tests for a double definition creator method that supports mocking'
   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
+  def double_definition_creator_for(object, &block)
+    mock(object, &block)
   end
 end