rr 1.1.1 → 3.0.0

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

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'mock', is_mock: true do
+  include MockDefinitionCreatorHelpers
+
+  context 'against instance methods', method_type: :instance do
+    include_context 'tests for a double definition creator method that supports mocking'
+  end
+
+  context 'against class methods', method_type: :class do
+    include_context 'tests for a double definition creator method that supports mocking'
+  end
+
+  def double_definition_creator_for(object, &block)
+    mock(object, &block)
+  end
+end

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

@@ -0,0 +1,102 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'spy' do
+  it "records invocations of most methods on a given object" do
+    subject = String.new
+    def subject.some_method; end
+
+    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
+
+  it "excludes #class from the list of recorded methods" do
+    subject = Object.new
+    spy(subject)
+    subject.class
+    subject.should_not have_received.class
+  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
+
+  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
+
+  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

@@ -0,0 +1,71 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'stub' do
+  include StubDefinitionCreatorHelpers
+
+  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
+
+    context 'that do not exist', methods_exist: false do
+      include_context 'tests for a double definition creator method that supports stubbing'
+    end
+  end
+
+  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
+
+    context 'that do not exist', methods_exist: false do
+      include_context 'tests for a double definition creator method that supports stubbing'
+    end
+  end
+
+  def double_definition_creator_for(object, &block)
+    stub(object, &block)
+  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 nil
+  end
+
+  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
+
+  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)
+
+    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
+
+  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)
+
+    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

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

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

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

@@ -0,0 +1,128 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'ostruct'
+
+describe 'wildcard matchers' do
+  subject { Object.new }
+
+  describe '#anything' do
+    it "works outside a container" do
+      mock(subject).foo(anything)
+      subject.foo(:whatever)
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([anything])
+      subject.foo([:whatever])
+    end
+  end
+
+  describe '#boolean' do
+    it "works outside a container" do
+      mock(subject).foo(boolean)
+      subject.foo(false)
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([boolean])
+      subject.foo([false])
+    end
+  end
+
+  describe '#duck_type' do
+    it "works outside a container" do
+      mock(subject).foo(duck_type(:bar))
+      subject.foo(OpenStruct.new(:bar => 3))
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([duck_type(:bar)])
+      subject.foo([OpenStruct.new(:bar => 3)])
+    end
+  end
+
+  describe '#hash_including' do
+    it "works outside a container" do
+      mock(subject).foo(hash_including(:c => 'd'))
+      subject.foo(:a => 'b', :c => 'd')
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([hash_including(:c => 'd')])
+      subject.foo([{:a => 'b', :c => 'd'}])
+    end
+  end
+
+  describe '#is_a' do
+    context 'when outside a container' do
+      it "matches a simple value" do
+        mock(subject).foo(is_a(Symbol))
+        subject.foo(:symbol)
+      end
+
+      it "matches a container value" do
+        mock(subject).foo(is_a(Array))
+        subject.foo(['x', 'y'])
+      end
+    end
+
+    context 'within a container' do
+      it "matches a simple value" do
+        mock(subject).foo([is_a(Symbol)])
+        subject.foo([:symbol])
+      end
+
+      it "matches a container" do
+        mock(subject).foo([is_a(Hash)])
+        subject.foo([{:x => 'y'}])
+      end
+    end
+  end
+
+  describe '#numeric' do
+    it "works outside a container" do
+      mock(subject).foo(numeric)
+      subject.foo(3)
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([numeric])
+      subject.foo([3])
+    end
+  end
+
+  describe 'range' do
+    it "works outside a container" do
+      mock(subject).foo(1..5)
+      subject.foo(3)
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([1..5])
+      subject.foo([3])
+    end
+  end
+
+  describe 'regexp' do
+    it "works outside a container" do
+      mock(subject).foo(/foo/)
+      subject.foo('foobar')
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([/foo/])
+      subject.foo(['foobar'])
+    end
+  end
+
+  describe '#satisfy' do
+    it "works outside a container" do
+      mock(subject).foo(satisfy {|x| x == 'x' })
+      subject.foo('x')
+    end
+
+    it "works within a container too" do
+      mock(subject).foo([satisfy {|x| x == 'x' }])
+      subject.foo(['x'])
+    end
+  end
+end