dchelimsky-rspec 1.1.10

data/spec/spec/mocks/bug_report_10260_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe "An RSpec Mock" do
+  it "should hide internals in its inspect representation" do
+    m = mock('cup')
+    m.inspect.should =~ /#<Spec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/
+  end
+end

data/spec/spec/mocks/bug_report_10263_spec.rb

@@ -0,0 +1,24 @@
+describe "Mock" do
+  before do
+    @mock = mock("test mock")
+  end
+  
+  specify "when one example has an expectation (non-mock) inside the block passed to the mock" do
+    @mock.should_receive(:msg) do |b|
+      b.should be_true #this call exposes the problem
+    end
+    @mock.msg(false) rescue nil
+  end
+  
+  specify "then the next example should behave as expected instead of saying" do
+    @mock.should_receive(:foobar)
+    @mock.foobar
+    @mock.rspec_verify
+    begin
+      @mock.foobar
+    rescue Exception => e
+      e.message.should == "Mock 'test mock' received unexpected message :foobar with (no args)"
+    end
+  end 
+end
+

data/spec/spec/mocks/bug_report_11545_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+class LiarLiarPantsOnFire
+  include Spec::MetaClass
+  extend Spec::MetaClass
+  def respond_to?(sym)
+    true
+  end
+  
+  def self.respond_to?(sym)
+    true
+  end
+end
+  
+describe 'should_receive' do
+  before(:each) do
+    @liar = LiarLiarPantsOnFire.new
+  end
+  
+  it "should work when object lies about responding to a method" do
+    @liar.should_receive(:something)
+    @liar.something
+  end
+
+  it 'should work when class lies about responding to a method' do
+    LiarLiarPantsOnFire.should_receive(:something)
+    LiarLiarPantsOnFire.something
+  end
+  
+  it 'should cleanup after itself' do
+    LiarLiarPantsOnFire.metaclass.instance_methods.should_not include("something")
+  end
+end

data/spec/spec/mocks/bug_report_15719_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "mock failure" do
+      
+      it "should tell you when it receives the right message with the wrong args" do
+        m = mock("foo")
+        m.should_receive(:bar).with("message")
+        lambda {
+          m.bar("different message")
+        }.should raise_error(Spec::Mocks::MockExpectationError, %Q{Mock 'foo' expected :bar with ("message") but received it with ("different message")})
+        m.bar("message") # allows the spec to pass
+      end
+
+      it "should tell you when it receives the right message with the wrong args if you stub the method" do
+        pending("fix bug 15719")
+        # NOTE - for whatever reason, if you use a the block style of pending here,
+        # rcov gets unhappy. Don't know why yet.
+        m = mock("foo")
+        m.stub!(:bar)
+        m.should_receive(:bar).with("message")
+        lambda {
+          m.bar("different message")
+        }.should raise_error(Spec::Mocks::MockExpectationError, %Q{Mock 'foo' expected :bar with ("message") but received it with ("different message")})
+        m.bar("message") # allows the spec to pass
+      end
+    end
+  end
+end

data/spec/spec/mocks/bug_report_496.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+class BaseClass
+end
+
+class SubClass < BaseClass
+end
+
+describe "a message expectation on a base class object" do
+  it "should correctly pick up message sent to it subclass" do
+    pending("fix for http://rspec.lighthouseapp.com/projects/5645-rspec/tickets/496") do
+      BaseClass.should_receive(:new).once
+      SubClass.new
+    end
+  end
+end
+

data/spec/spec/mocks/bug_report_7611_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Bug7611
+  class Foo
+  end
+
+  class Bar < Foo
+  end
+
+  describe "A Partial Mock" do
+    it "should respect subclasses" do
+      Foo.stub!(:new).and_return(Object.new)
+    end
+
+    it "should" do
+      Bar.new.class.should == Bar
+    end 
+  end
+end

data/spec/spec/mocks/bug_report_7805_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Bug7805
+  #This is really a duplicate of 8302
+
+  describe "Stubs should correctly restore module methods" do
+    it "1 - stub the open method" do
+      File.stub!(:open).and_return("something")
+      File.open.should == "something"
+    end
+    it "2 - use File.open to create example.txt" do
+      filename = "#{File.dirname(__FILE__)}/example-#{Time.new.to_i}.txt"
+      File.exist?(filename).should be_false
+      file = File.open(filename,'w')
+      file.close
+      File.exist?(filename).should be_true
+      File.delete(filename)
+      File.exist?(filename).should be_false
+    end
+  end
+
+end

data/spec/spec/mocks/bug_report_8165_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe "An object where respond_to? is true and does not have method" do
+  # When should_receive(:sym) is sent to any object, the Proxy sends
+  # respond_to?(:sym) to that object to see if the method should be proxied.
+  #
+  # If respond_to? itself is proxied, then when the Proxy sends respond_to?
+  # to the object, the proxy is invoked and responds yes (if so set in the spec).
+  # When the object does NOT actually respond to :sym, an exception is thrown
+  # when trying to proxy it.
+  #
+  # The fix was to keep track of whether :respond_to? had been proxied and, if
+  # so, call the munged copy of :respond_to? on the object.
+
+  it "should not raise an exception for Object" do
+    obj = Object.new
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    obj.respond_to?(:foobar).should be_true
+    obj.foobar.should == :baz
+  end
+
+  it "should not raise an exception for mock" do
+    obj = mock("obj")
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    obj.respond_to?(:foobar).should be_true
+    obj.foobar.should == :baz
+  end
+
+end

data/spec/spec/mocks/bug_report_8302_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Bug8302
+  class Foo
+    def Foo.class_method(arg)
+    end
+  
+    def instance_bar(arg)
+    end
+  end
+
+  describe "Bug report 8302:" do
+    it "class method is not restored correctly when proxied" do
+      Foo.should_not_receive(:class_method).with(Array.new)
+      Foo.rspec_verify
+      Foo.class_method(Array.new)
+    end
+
+    it "instance method is not restored correctly when proxied" do
+      foo = Foo.new
+      foo.should_not_receive(:instance_bar).with(Array.new)
+      foo.rspec_verify
+      foo.instance_bar(Array.new)
+    end
+  end
+end

data/spec/spec/mocks/failing_mock_argument_constraints_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "failing MockArgumentConstraints" do
+      before(:each) do
+        @mock = mock("test mock")
+        @reporter = Mock.new("reporter", :null_object => true)
+      end
+      
+      after(:each) do
+        @mock.rspec_reset
+      end
+
+      it "should reject non boolean" do
+        @mock.should_receive(:random_call).with(boolean())
+        lambda do
+          @mock.random_call("false")
+        end.should raise_error(MockExpectationError)
+      end
+
+      it "should reject non numeric" do
+        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
+        lambda do
+          @mock.random_call("1")
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "should reject non string" do
+        @mock.should_receive(:random_call).with(an_instance_of(String))
+        lambda do
+          @mock.random_call(123)
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "should reject goose when expecting a duck" do
+        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
+        lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError)
+      end
+
+      it "should fail if regexp does not match submitted string" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        lambda { @mock.random_call("abc") }.should raise_error(MockExpectationError)
+      end
+      
+      it "should fail if regexp does not match submitted regexp" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        lambda { @mock.random_call(/bcde/) }.should raise_error(MockExpectationError)
+      end
+      
+      it "should fail for a hash w/ wrong values" do
+        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
+        lambda do
+          @mock.random_call(:a => "b", :c => "e")
+        end.should raise_error(MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+      end
+      
+      it "should fail for a hash w/ wrong keys" do
+        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
+        lambda do
+          @mock.random_call("a" => "b", "c" => "d")
+        end.should raise_error(MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+      end
+      
+      it "should match against a Matcher" do
+        lambda do
+          @mock.should_receive(:msg).with(equal(3))
+          @mock.msg(37)
+        end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (equal 3) but received it with (37)")
+      end
+      
+      it "should fail no_args with one arg" do
+        lambda do
+          @mock.should_receive(:msg).with(no_args)
+          @mock.msg(37)
+        end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (no args) but received it with (37)")
+      end
+      
+      it "should fail hash_including with missing key" do
+         lambda do
+           @mock.should_receive(:msg).with(hash_including(:a => 1))
+           @mock.msg({})
+         end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (hash_including(:a=>1)) but received it with ({})")
+      end
+
+      it "should fail with block constraints" do
+        lambda do
+          @mock.should_receive(:msg).with {|arg| arg.should == :received }
+          @mock.msg :no_msg_for_you
+        end.should raise_error(Spec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+      end
+            
+    end
+  end
+end

data/spec/spec/mocks/hash_including_matcher_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    module ArgumentConstraints
+      describe HashIncludingConstraint do
+        
+        it "should describe itself properly" do
+          HashIncludingConstraint.new(:a => 1).description.should == "hash_including(:a=>1)"
+        end      
+
+        describe "passing" do
+          it "should match the same hash" do
+            hash_including(:a => 1).should == {:a => 1}
+          end
+
+          it "should match a hash with extra stuff" do
+            hash_including(:a => 1).should == {:a => 1, :b => 2}
+          end
+          
+          describe "when matching against other constraints" do
+            it "should match an int against anything()" do
+              hash_including(:a => anything, :b => 2).should == {:a => 1, :b => 2}
+            end
+
+            it "should match a string against anything()" do
+              hash_including(:a => anything, :b => 2).should == {:a => "1", :b => 2}
+            end
+          end
+        end
+        
+        describe "failing" do
+          it "should not match a non-hash" do
+            hash_including(:a => 1).should_not == 1
+          end
+
+
+          it "should not match a hash with a missing key" do
+            hash_including(:a => 1).should_not == {:b => 2}
+          end
+
+          it "should not match a hash with an incorrect value" do
+            hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3}
+          end
+
+          it "should not match when values are nil but keys are different" do
+            hash_including(:a => nil).should_not == {:b => nil}
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec/mocks/mock_ordering_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Mocks
+
+    describe "Mock ordering" do
+
+      before do
+        @mock = mock("test mock")
+      end
+      
+      after do
+        @mock.rspec_reset
+      end
+
+      it "should pass two calls in order" do
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        @mock.one
+        @mock.two
+        @mock.rspec_verify
+      end
+
+      it "should pass three calls in order" do
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        @mock.should_receive(:three).ordered
+        @mock.one
+        @mock.two
+        @mock.three
+        @mock.rspec_verify
+      end
+
+      it "should fail if second call comes first" do
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        lambda do
+          @mock.two
+        end.should raise_error(MockExpectationError, "Mock 'test mock' received :two out of order")
+      end
+
+      it "should fail if third call comes first" do
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        @mock.should_receive(:three).ordered
+        @mock.one
+        lambda do
+          @mock.three
+        end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
+      end
+      
+      it "should fail if third call comes second" do
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        @mock.should_receive(:three).ordered
+        @mock.one
+        lambda do
+          @mock.three
+        end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
+      end
+
+      it "should ignore order of non ordered calls" do
+        @mock.should_receive(:ignored_0)
+        @mock.should_receive(:ordered_1).ordered
+        @mock.should_receive(:ignored_1)
+        @mock.should_receive(:ordered_2).ordered
+        @mock.should_receive(:ignored_2)
+        @mock.should_receive(:ignored_3)
+        @mock.should_receive(:ordered_3).ordered
+        @mock.should_receive(:ignored_4)
+        @mock.ignored_3
+        @mock.ordered_1
+        @mock.ignored_0
+        @mock.ordered_2
+        @mock.ignored_4
+        @mock.ignored_2
+        @mock.ordered_3
+        @mock.ignored_1
+        @mock.rspec_verify
+      end
+            
+    end
+  end
+end