rr 1.1.2 → 1.2.0

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

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

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

@@ -0,0 +1,16 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'received' do
+  it "doesn't throw an error if the invocation occurred" do
+    stub(subject).pig_rabbit
+    subject.pig_rabbit('bacon', 'bunny meat')
+    received(subject).pig_rabbit('bacon', 'bunny meat').call
+  end
+
+  it "throws a SpyVerificationError if the invocation did not occur" do
+    stub(subject).pig_rabbit
+    expect {
+      received(subject).pig_rabbit('bacon', 'bunny meat').call
+    }.to raise_error(RR::Errors::SpyVerificationErrors::SpyVerificationError)
+  end
+end

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

@@ -1,41 +1,102 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe '#spy' do
-  subject { Object.new }
+describe 'spy' do
+  it "records invocations of most methods on a given object" do
+    subject = String.new
+    def subject.some_method; end
 
-  it "should record all method invocations" do
+    spy(subject)
+
+    subject.some_method
+    subject.reverse
+    subject.chomp
+
+    subject.should have_received.some_method
+    subject.should have_received.reverse
+    subject.should have_received.chomp
+  end
+
+  it "excludes #methods from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.methods
+    subject.should_not have_received.methods
+  end
+
+  it "excludes #== from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject == 5
+    subject.should_not have_received(:==)
+  end
+
+  it "excludes #__send__ from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.__send__('to_s')
+    subject.should_not have_received(:__send__)
+  end
+
+  it "excludes #__id__ from the list of recorded methods" do
     subject = Object.new
+    spy(subject)
+    subject.__id__
+    subject.should_not have_received(:__id__)
+  end
+
+  it "excludes #object_id from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.object_id
+    subject.should_not have_received(:object_id)
+  end
 
-    def subject.something
-    end
+  it "excludes #class from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.class
+    subject.should_not have_received.class
+  end
 
-    def subject.something_else
-    end
+  it "excludes #respond_to? from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.respond_to?(:foo)
+    subject.should_not have_received(:respond_to?)
+  end
 
+  it "excludes #respond_to? from the list of recorded methods" do
+    subject = Object.new
     spy(subject)
+    subject.inspect
+    subject.should_not have_received.inspect
+  end
 
-    subject.something
-    subject.something_else
+  it "excludes #respond_to? from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
     subject.to_s
+    subject.should_not have_received.to_s
+  end
+
+  it "excludes #respond_to_missing? from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.__send__(:respond_to_missing?, :foo, [])
+    subject.should_not have_received(:respond_to_missing?)
+  end
 
-    received(subject).something.call
-    received(subject).something_else.call
-    received(subject).to_s.call
-  end
-
-  describe "RR recorded_calls" do
-    it "should verify method calls after the fact" do
-      stub(subject).pig_rabbit
-      subject.pig_rabbit("bacon", "bunny meat")
-      #expect(subject).to have_received.pig_rabitt("bacon", "bunny meat")
-      received(subject).pig_rabbit("bacon", "bunny meat").call
-    end
-
-    it "should verify method calls after the fact" do
-      stub(subject).pig_rabbit
-      expect {
-        received(subject).pig_rabbit("bacon", "bunny meat").call
-      }.to raise_error(RR::Errors::SpyVerificationErrors::SpyVerificationError)
-    end
+  it "excludes #instance_eval from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.instance_eval {}
+    subject.should_not have_received(:instance_eval)
+  end
+
+  it "excludes #instance_exec from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.instance_exec {}
+    subject.should_not have_received(:instance_exec)
   end
 end

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

@@ -0,0 +1,20 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'stub!' do
+  it "is a terser way of creating an object and stubbing it" do
+    object = stub!.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 { stub!.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.stub!.another_method { 'value' }
+    expect(object.some_method.another_method).to eq 'value'
+  end
+end

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

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

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

@@ -0,0 +1,15 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  (%w(stub instance_of strong).permutation.to_a + %w(instance_of strong).permutation.to_a).
+  map { |parts| parts.join('.') }
+
+permutations.each do |permutation|
+  describe permutation, is_instance_of: true, is_strong: true do
+    include_context 'stub + 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/stub_proxy_instance_of_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  %w(stub proxy instance_of).permutation.map { |parts| parts.join('.') } +
+  %w(proxy instance_of).permutation.map { |parts| parts.join('.') }
+
+permutations.each do |permutation|
+  describe permutation, is_proxy: true, is_instance_of: true do
+    include_context 'stub + 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/stub_proxy_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+permutations =
+  %w(stub proxy).permutation.map { |parts| parts.join('.') } +
+  %w(proxy)
+
+permutations.each do |permutation|
+  describe permutation, is_proxy: true do
+    include_context 'stub + proxy'
+
+    define_method(:double_definition_creator_for) do |object, &block|
+      eval(permutation + '(object, &block)')
+    end
+  end
+
+  def expect_that_double_can_be_defined_without_block
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value', nil)
+    expect(return_value).to eq 'value'
+  end
+
+  def expect_that_double_sets_implementation(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value', ->(v) { v.upcase }, &block)
+    expect(return_value).to eq 'VALUE'
+  end
+
+  def expect_that_double_sets_implementation_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('value', ->(v) { v.upcase }, &block)
+    expect(return_value).to eq 'value'
+  end
+
+  def expect_that_double_sets_value(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', 'new value', &block)
+    expect(return_value).to eq 'new value'
+  end
+
+  def expect_that_double_sets_value_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', 'new value', &block)
+    expect(return_value).to eq 'old value'
+  end
+end

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

@@ -1,190 +1,71 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-class StubSpecFixture
-  attr_reader :initialize_arguments
+describe 'stub' do
+  include StubDefinitionCreatorHelpers
 
-  def initialize(*args)
-    @initialize_arguments = args
-    yield if block_given?
-    method_run_in_initialize
-  end
-
-  def method_run_in_initialize
-
-  end
-end
-
-describe '#stub' do
-  subject { Object.new }
-
-  it "creates a stub DoubleInjection Double" do
-    stub(subject).foobar {:baz}
-    expect(subject.foobar("any", "thing")).to eq :baz
-  end
-
-  it "stubs via inline call" do
-    stub(subject).to_s {"a value"}
-    expect(subject.to_s).to eq "a value"
-  end
-
-  describe ".once.ordered" do
-    it "returns the values in the ordered called" do
-      stub(subject).to_s {"value 1"}.once.ordered
-      stub(subject).to_s {"value 2"}.once.ordered
-
-      expect(subject.to_s).to eq "value 1"
-      expect(subject.to_s).to eq "value 2"
+  context 'against instance methods', method_type: :instance do
+    context 'that exist', methods_exist: true do
+      include_context 'tests for a double definition creator method that supports stubbing'
     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)
 
-      stub(proxy).foobar {:new_foobar}
-      expect(proxy.foobar).to eq :new_foobar
+    context 'that do not exist', methods_exist: false do
+      include_context 'tests for a double definition creator method that supports stubbing'
     end
   end
 
-  it "stubs via block with argument" do
-    stub subject do |d|
-      d.to_s {"a value"}
-      d.to_sym {:crazy}
+  context 'against class methods', method_type: :class do
+    context 'that exist', methods_exist: true do
+      include_context 'tests for a double definition creator method that supports stubbing'
     end
-    expect(subject.to_s).to eq "a value"
-    expect(subject.to_sym).to eq :crazy
-  end
 
-  it "stubs via block without argument" do
-    stub subject do
-      to_s {"a value"}
-      to_sym {:crazy}
+    context 'that do not exist', methods_exist: false do
+      include_context 'tests for a double definition creator method that supports stubbing'
     end
-    expect(subject.to_s).to eq "a value"
-    expect(subject.to_sym).to eq :crazy
   end
 
-  it "stubs instance_of" do
-    stub.instance_of(StubSpecFixture) do |o|
-      o.to_s {"High Level Spec"}
-    end
-    expect(StubSpecFixture.new.to_s).to eq "High Level Spec"
+  def double_definition_creator_for(object, &block)
+    stub(object, &block)
   end
 
-  it "stubs methods without letters" do
-    stub(subject).__send__(:==) {:equality}
-    expect((subject == 55)).to eq :equality
+  def expect_that_double_can_be_defined_without_block
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('value', nil)
+    expect(return_value).to eq nil
   end
 
-  it "stubs methods invoked in #initialize while passing along the #initialize arg" do
-    method_run_in_initialize_stubbed = false
-    stub.instance_of(StubSpecFixture) do |o|
-      o.method_run_in_initialize {method_run_in_initialize_stubbed = true}
-    end
-    StubSpecFixture.new
-    expect(method_run_in_initialize_stubbed).to be_true
+  def expect_that_double_sets_implementation(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', -> { 'new value' }, &block)
+    expect(return_value).to eq 'new value'
   end
 
-  it "passed the arguments and block passed to #initialize" do
-    block_called = false
-    stub.instance_of(StubSpecFixture) do |o|
-      o.method_run_in_initialize
-    end
-    instance = StubSpecFixture.new(1, 2) {block_called = true}
-    expect(instance.initialize_arguments).to eq [1, 2]
-    expect(block_called).to be_true
-  end
+  def expect_that_double_sets_implementation_and_resets(&block)
+    object, method_name, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', -> { 'new value' }, &block)
 
-  context "mock then stub" do
-    it "stubs any calls not matching the mock" do
-      mock(subject).foobar(3) {:baz3}
-      stub(subject).foobar {:baz}
-      expect(subject.foobar(3)).to eq :baz3
-      expect(subject.foobar(4)).to eq :baz
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
     end
   end
 
-  context "stub that yields" do
-    context "when yields called without any arguments" do
-      it "yields only once" do
-        called_from_block = mock!.foo.once.subject
-        block_caller = stub!.bar.yields.subject
-        block_caller.bar { called_from_block.foo }
-      end
-    end
-
-    context "when yields called with an argument" do
-      it "yields only once" do
-        called_from_block = mock!.foo(1).once.subject
-        block_caller = stub!.bar.yields(1).subject
-        block_caller.bar { |argument| called_from_block.foo(argument) }
-      end
-    end
-
-    context "when yields calls are chained" do
-      it "yields several times" do
-        pending "This test is failing with a TimesCalledError"
-
-        called_from_block = mock!.foo(1).once.then.foo(2).once.subject
-        block_caller = stub!.bar.yields(1).yields(2).subject
-        block_caller.bar { |argument| called_from_block.foo(argument) }
-      end
-    end
+  def expect_that_double_sets_value(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_called('old value', 'new value', &block)
+    expect(return_value).to eq 'new value'
   end
 
-  # bug #44
-  describe 'when wrapped in an array that is then flattened' do
-    context 'when the method being stubbed is not defined' do
-      it "does not raise an error" do
-        stub(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
-        stub(subject).foo
-        expect([subject].flatten).to eq []
-      end
-    end
-
-    context 'when the method being stubbed is defined' do
-      before do
-        subject.instance_eval do
-          def foo; end
-        end
-      end
-
-      it "does not raise an error" do
-        stub(subject).foo
-        expect([subject].flatten).to eq [subject]
-      end
+  def expect_that_double_sets_value_and_resets(&block)
+    _, _, return_value =
+      build_object_with_doubled_method_which_is_reset_and_called('old value', 'new value', &block)
 
-      it "honors a #to_ary that already exists" do
-        eigen(subject).class_eval do
-          def to_ary; []; end
-        end
-        stub(subject).foo
-        expect([subject].flatten).to eq []
-      end
+    if methods_being_doubled_exist_already?
+      # This doesn't work quite yet - see btakita#44
+      #expect(object).not_to respond_to(method_name)
+    else
+      expect(return_value).to eq 'old value'
     end
   end
 end