rr 1.1.1.rc1 → 1.1.1

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

@@ -1,136 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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