rr 1.1.1 → 1.1.2.rc1

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

@@ -0,0 +1,136 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe '#proxy' do
+  subject { Object.new }
+
+  it "proxies via inline call" do
+    expected_to_s_value = subject.to_s
+    mock.proxy(subject).to_s
+    expect(subject.to_s).to eq expected_to_s_value
+    expect { subject.to_s }.to raise_error
+    RR.reset
+  end
+
+  it "proxy allows ordering" do
+    def subject.to_s(arg)
+      "Original to_s with arg #{arg}"
+    end
+    mock.proxy(subject).to_s(:foo).ordered
+    mock.proxy(subject).to_s(:bar).twice.ordered
+
+    expect(subject.to_s(:foo)).to eq "Original to_s with arg foo"
+    expect(subject.to_s(:bar)).to eq "Original to_s with arg bar"
+    expect(subject.to_s(:bar)).to eq "Original to_s with arg bar"
+    expect { subject.to_s(:bar) }.to raise_error(RR::Errors::TimesCalledError)
+
+    RR.reset
+  end
+
+  it "proxy allows ordering" do
+    def subject.to_s(arg)
+      "Original to_s with arg #{arg}"
+    end
+    mock.proxy(subject).to_s(:foo).ordered
+    mock.proxy(subject).to_s(:bar).twice.ordered
+
+    expect(subject.to_s(:foo)).to eq "Original to_s with arg foo"
+    expect(subject.to_s(:bar)).to eq "Original to_s with arg bar"
+    expect(subject.to_s(:bar)).to eq "Original to_s with arg bar"
+    expect { subject.to_s(:bar) }.to raise_error(RR::Errors::TimesCalledError)
+
+    RR.reset
+  end
+
+  it "proxies via block with argument" do
+    def subject.foobar_1(*args)
+      :original_value_1
+    end
+
+    def subject.foobar_2
+      :original_value_2
+    end
+
+    mock.proxy subject do |c|
+      c.foobar_1(1)
+      c.foobar_2
+    end
+    expect(subject.foobar_1(1)).to eq :original_value_1
+    expect { subject.foobar_1(:blah) }.to raise_error
+
+    expect(subject.foobar_2).to eq :original_value_2
+    expect { subject.foobar_2(:blah) }.to raise_error
+
+    RR.reset
+  end
+
+  it "proxies via block without argument" do
+    def subject.foobar_1(*args)
+      :original_value_1
+    end
+
+    def subject.foobar_2
+      :original_value_2
+    end
+
+    mock.proxy subject do
+      foobar_1(1)
+      foobar_2
+    end
+    expect(subject.foobar_1(1)).to eq :original_value_1
+    expect { subject.foobar_1(:blah) }.to raise_error
+
+    expect(subject.foobar_2).to eq :original_value_2
+    expect { subject.foobar_2(:blah) }.to raise_error
+
+    RR.reset
+  end
+
+  # bug #44
+  describe 'when wrapped in an array that is then flattened' do
+    subject {
+      Object.new.tap do |o|
+        def o.foo; end
+      end
+    }
+
+    context 'when the method being mocked is not defined' do
+      it "does not raise an error" do
+        mock.proxy(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.proxy(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.proxy(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.proxy(subject).foo
+        subject.foo
+        expect([subject].flatten).to eq []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe '#spy' do
+  subject { Object.new }
+
+  it "should record all method invocations" do
+    subject = Object.new
+
+    def subject.something
+    end
+
+    def subject.something_else
+    end
+
+    spy(subject)
+
+    subject.something
+    subject.something_else
+    subject.to_s
+
+    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
+  end
+end

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

@@ -0,0 +1,79 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+class StrongSpecFixture
+  def method_with_no_arguments
+  end
+
+  def method_with_one_argument(string)
+  end
+
+  def method_with_two_arguments(string, integer)
+  end
+
+  def method_with_three_arguments_including_varargs(string, integer, *args)
+  end
+
+  def method_with_varargs(*args)
+  end
+end
+
+describe '#strong' do
+  subject { Object.new }
+
+  context "when the method does not exist" do
+    it "raises an exception" do
+      expect {
+        strong.stub(StrongSpecFixture.new).something
+      }.to raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+    end
+  end
+
+  context "when the method exists with no arguments" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_no_arguments
+    end
+  end
+
+  context "when the method has a different arity" do
+    it "raises an exception" do
+      expect {
+        strong.stub(StrongSpecFixture.new).method_with_one_argument
+      }.to raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  context "when the method has accepts a variable number of arguments" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_varargs
+    end
+  end
+
+  context "when the method does not provide the required parameters before varargs" do
+    it "raises an exception" do
+      expect {
+        strong.stub(StrongSpecFixture.new).method_with_three_arguments_including_varargs
+      }.to raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  context "when the minimum number of parameters are provided" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_three_arguments_including_varargs("one", 2)
+    end
+  end
+
+  context "when using instance_of and the method does not exist" do
+    it "raises an exception" do
+      expect {
+        strong.stub.instance_of(StrongSpecFixture).something
+        StrongSpecFixture.new
+      }.to raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+    end
+  end
+
+  context "when using instance_of and the method does exist" do
+    it "does not raise an exception" do
+      strong.stub.instance_of(StrongSpecFixture).method_with_no_arguments
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+class StubSpecFixture
+  attr_reader :initialize_arguments
+
+  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"
+    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
+    end
+  end
+
+  it "stubs via block with argument" do
+    stub subject do |d|
+      d.to_s {"a value"}
+      d.to_sym {:crazy}
+    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}
+    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"
+  end
+
+  it "stubs methods without letters" do
+    stub(subject).__send__(:==) {:equality}
+    expect((subject == 55)).to eq :equality
+  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
+  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
+
+  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
+    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
+  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
+
+      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
+    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