rspec 1.0.0 → 1.3.1

data/spec/spec/matchers/throw_symbol_spec.rb

@@ -1,50 +1,120 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Matchers
-    describe ThrowSymbol, "(constructed with no Symbol)" do
-      before(:each) { @matcher = ThrowSymbol.new }
+    describe ThrowSymbol do
+      describe "with no args" do
+        let(:matcher) { throw_symbol }
 
-      it "should match if any Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
-      end
-      it "should not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "should provide a failure message" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
-      end
-      it "should provide a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym})
-        @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
-      end
-    end
-    
-    describe ThrowSymbol, "(constructed with a Symbol)" do
-      before(:each) { @matcher = ThrowSymbol.new(:sym) }
-      
-      it "should match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
-      end
-      it "should not match no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "should not match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym }).should be_false
-        @matcher.failure_message.should == "expected :sym, got :other_sym"
-      end
-      it "should provide a failure message when no Symbol is thrown" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message.should == "expected :sym but nothing was thrown"
+        it "matches if any Symbol is thrown" do
+          matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+
+        it "matches if any Symbol is thrown with an arg" do
+          matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+
+        it "does not match if no Symbol is thrown" do
+          matcher.matches?(lambda{ }).should be_false
+        end
+
+        it "provides a failure message" do
+          matcher.matches?(lambda{})
+          matcher.failure_message_for_should.should == "expected a Symbol but nothing was thrown"
+        end
+
+        it "provides a negative failure message" do
+          matcher.matches?(lambda{ throw :sym})
+          matcher.failure_message_for_should_not.should == "expected no Symbol, got :sym"
+        end
       end
-      it "should provide a failure message when wrong Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym })
-        @matcher.failure_message.should == "expected :sym, got :other_sym"
+
+      describe "with a symbol" do
+        let(:matcher) { throw_symbol(:sym) }
+
+        it "matches if correct Symbol is thrown" do
+          matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+
+        it "matches if correct Symbol is thrown with an arg" do
+          matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+
+        it "does not match if no Symbol is thrown" do
+          matcher.matches?(lambda{ }).should be_false
+        end
+
+        it "does not match if correct Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym }).should be_false
+        end
+
+        it "provides a failure message when no Symbol is thrown" do
+          matcher.matches?(lambda{})
+          matcher.failure_message_for_should.should == "expected :sym but nothing was thrown"
+        end
+
+        it "provides a failure message when wrong Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym })
+          matcher.failure_message_for_should.should == "expected :sym, got :other_sym"
+        end
+
+        it "provides a negative failure message" do
+          matcher.matches?(lambda{ throw :sym })
+          matcher.failure_message_for_should_not.should == "expected :sym not to be thrown"
+        end
+
+        it "should only match NameErrors raised by uncaught throws" do
+          matcher.matches?(lambda{ :sym }).should be_false
+        end
+        
+        it "bubbles up errors other than NameError" do
+          lambda do
+            matcher.matches?(lambda{ raise 'foo' })
+          end.should raise_error('foo')
+        end
       end
-      it "should provide a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym })
-        @matcher.negative_failure_message.should == "expected :sym not to be thrown"
+
+      describe "with a symbol and an arg" do
+        let(:matcher) { throw_symbol(:sym, "a") }
+
+        it "matches if correct Symbol and args are thrown" do
+          matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+        end
+
+        it "does not match if nothing is thrown" do
+          matcher.matches?(lambda{ }).should be_false
+        end
+
+        it "does not match if other Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+        end
+
+        it "does not match if no arg is thrown" do
+          matcher.matches?(lambda{ throw :sym }).should be_false
+        end
+
+        it "does not match if wrong arg is thrown" do
+          matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+        end
+
+        it "provides a failure message when no Symbol is thrown" do
+          matcher.matches?(lambda{})
+          matcher.failure_message_for_should.should == %q[expected :sym with "a" but nothing was thrown]
+        end
+
+        it "provides a failure message when wrong Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym })
+          matcher.failure_message_for_should.should == %q[expected :sym with "a", got :other_sym]
+        end
+
+        it "provides a negative failure message" do
+          matcher.matches?(lambda{ throw :sym })
+          matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown]
+        end
+
+        it "only matches NameErrors raised by uncaught throws" do
+          matcher.matches?(lambda{ :sym }).should be_false
+        end
       end
     end
   end

data/spec/spec/mocks/and_yield_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe Mock do
+      describe "#and_yield" do
+
+        context "with eval context as block argument" do
+          let(:obj) { double }
+
+          it "evaluates the supplied block as it is read" do
+            evaluated = false
+            obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+              evaluated = true
+            end
+            evaluated.should be_true
+          end
+
+          it "passes an eval context object to the supplied block" do
+            obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+              eval_context.should_not be_nil
+            end
+          end
+
+          it "evaluates the block passed to the stubbed method in the context of the supplied eval context" do
+            expected_eval_context = nil
+            actual_eval_context = nil
+
+            obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+              expected_eval_context = eval_context
+            end
+
+            obj.method_that_accepts_a_block do
+              actual_eval_context = self
+            end
+
+            actual_eval_context.should equal(expected_eval_context)
+          end
+
+          context "and no yielded arguments" do
+
+            it "passes when expectations set on the eval context are met" do
+              configured_eval_context = nil
+              obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+              end
+
+              obj.method_that_accepts_a_block do
+                foo
+              end
+
+              configured_eval_context.rspec_verify
+            end
+
+            it "fails when expectations set on the eval context are not met" do
+              configured_eval_context = nil
+              obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+              end
+
+              obj.method_that_accepts_a_block do
+                # foo is not called here
+              end
+
+              lambda {configured_eval_context.rspec_verify}.should raise_error(MockExpectationError)
+            end
+
+          end
+
+          context "and yielded arguments" do
+
+            it "passes when expectations set on the eval context and yielded arguments are met" do
+              configured_eval_context = nil
+              yielded_arg = Object.new
+              obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+                yielded_arg.should_receive(:bar)
+              end
+
+              obj.method_that_accepts_a_block do |obj|
+                obj.bar
+                foo
+              end
+
+              configured_eval_context.rspec_verify
+              yielded_arg.rspec_verify
+            end
+
+            it "fails when expectations set on the eval context and yielded arguments are not met" do
+              configured_eval_context = nil
+              yielded_arg = Object.new
+              obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+                yielded_arg.should_receive(:bar)
+              end
+
+              obj.method_that_accepts_a_block do |obj|
+                # obj.bar is not called here
+                # foo is not called here
+              end
+
+              lambda {configured_eval_context.rspec_verify}.should raise_error(MockExpectationError)
+              lambda {yielded_arg.rspec_verify}.should raise_error(MockExpectationError)
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/spec/spec/mocks/any_number_of_times_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -23,7 +23,14 @@ module Spec
       it "should pass if any number of times method is not called" do
         @mock.should_receive(:random_call).any_number_of_times
       end
+
+      it "should return the mocked value when called after a similar stub" do
+        @mock.stub!(:message).and_return :stub_value
+        @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
+        @mock.message.should == :mock_value
+        @mock.message.should == :mock_value
+      end
     end
 
   end
-end
+end

data/spec/spec/mocks/argument_expectation_spec.rb

@@ -1,19 +1,23 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
-describe "An ArgumentExpectation" do
-  it "should consider an object that responds to #matches? and #description to be a matcher" do
-    argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
-    obj = mock("matcher")
-    obj.should_receive(:respond_to?).with(:matches?).and_return(true)
-    obj.should_receive(:respond_to?).with(:description).and_return(true)
-    argument_expecatation.is_matcher?(obj).should be_true
-  end
+module Spec
+  module Mocks
+    describe ArgumentExpectation do
+      it "should consider an object that responds to #matches? and #description to be a matcher" do
+        argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
+        obj = mock("matcher")
+        obj.should_receive(:respond_to?).with(:matches?).and_return(true)
+        obj.should_receive(:respond_to?).with(:description).and_return(true)
+        argument_expecatation.is_matcher?(obj).should be_true
+      end
 
-  it "should NOT consider an object that only responds to #matches? to be a matcher" do
-    argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
-    obj = mock("matcher")
-    obj.should_receive(:respond_to?).with(:matches?).and_return(true)
-    obj.should_receive(:respond_to?).with(:description).and_return(false)
-    argument_expecatation.is_matcher?(obj).should be_false
+      it "should NOT consider an object that only responds to #matches? to be a matcher" do
+        argument_expecatation = Spec::Mocks::ArgumentExpectation.new([])
+        obj = mock("matcher")
+        obj.should_receive(:respond_to?).with(:matches?).and_return(true)
+        obj.should_receive(:respond_to?).with(:description).and_return(false)
+        argument_expecatation.is_matcher?(obj).should be_false
+      end
+    end
   end
 end

data/spec/spec/mocks/argument_matchers_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    module ArgumentMatchers
+      describe AnyArgsMatcher do
+        it "represents itself nicely for failure messages" do
+          AnyArgsMatcher.new.description.should == "any args"
+        end
+      end
+
+      describe AnyArgMatcher do
+        it "represents itself nicely for failure messages" do
+          AnyArgMatcher.new(nil).description.should == "anything"
+        end
+      end
+    end
+  end
+end

data/spec/spec/mocks/at_least_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -94,4 +94,4 @@ module Spec
       end
     end
   end
-end
+end

data/spec/spec/mocks/at_most_spec.rb

@@ -1,8 +1,8 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
-    describe "AtMost" do
+    describe "at_most" do
       before(:each) do
         @mock = Mock.new("test mock")
       end
@@ -90,4 +90,4 @@ module Spec
       end
     end
   end
-end
+end

data/spec/spec/mocks/bug_report_10260_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 describe "An RSpec Mock" do
   it "should hide internals in its inspect representation" do

data/spec/spec/mocks/bug_report_10263_spec.rb

@@ -0,0 +1,27 @@
+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
+    begin
+      @mock.msg(false)
+    rescue Exception
+    end
+  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,32 @@
+require 'spec_helper'
+
+class LiarLiarPantsOnFire
+  def respond_to?(sym, incl_private=false)
+    true
+  end
+  
+  def self.respond_to?(sym, incl_private=false)
+    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
+    (class << LiarLiarPantsOnFire; self; end).instance_methods.should_not include("something")
+  end
+end
+

data/spec/spec/mocks/bug_report_15719_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+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" received :bar with unexpected arguments\n  expected: ("message")\n       got: ("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" received :bar with unexpected arguments\n  expected: ("message")\n       got: ("different message")})
+        m.bar("message") # allows the spec to pass
+      end
+    end
+  end
+end

data/spec/spec/mocks/bug_report_496_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module BugReport496
+  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
+      BaseClass.should_receive(:new).once
+      SubClass.new
+    end
+  end
+end
+

data/spec/spec/mocks/bug_report_600_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module BugReport600
+  class ExampleClass
+    def self.method_that_uses_define_method
+      define_method "defined_method" do |attributes|
+        load_address(address, attributes)
+      end
+    end
+  end
+ 
+  describe "stubbing a class method" do
+    it "should work" do
+      ExampleClass.should_receive(:define_method).with("defined_method")
+      ExampleClass.method_that_uses_define_method
+    end
+
+    it "should restore the original method" do
+      ExampleClass.method_that_uses_define_method
+    end
+  end
+end

data/spec/spec/mocks/bug_report_7611_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Bug7611
   class Foo
@@ -16,4 +16,4 @@ module Bug7611
       Bar.new.class.should == Bar
     end 
   end
-end
+end

data/spec/spec/mocks/bug_report_7805_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Bug7805
   #This is really a duplicate of 8302
@@ -19,4 +19,4 @@ module Bug7805
     end
   end
 
-end
+end

data/spec/spec/mocks/bug_report_8165_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 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
@@ -12,7 +12,7 @@ describe "An object where respond_to? is true and does not have method" do
   # 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" do
+  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)
@@ -20,7 +20,7 @@ describe "An object where respond_to? is true and does not have method" do
     obj.foobar.should == :baz
   end
 
-  it "should not raise an exception" do
+  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)
@@ -28,4 +28,4 @@ describe "An object where respond_to? is true and does not have method" do
     obj.foobar.should == :baz
   end
 
-end
+end

data/spec/spec/mocks/bug_report_8302_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Bug8302
   class Foo
@@ -23,4 +23,4 @@ module Bug8302
       foo.instance_bar(Array.new)
     end
   end
-end
+end

data/spec/spec/mocks/bug_report_830_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe 'Calling a method that catches StandardError' do
+      class Foo
+        def self.foo
+          bar
+        rescue StandardError
+        end
+      end
+
+      it 'still reports mock failures' do
+        Foo.should_not_receive :bar
+        lambda do
+          Foo.foo
+        end.should raise_error(MockExpectationError)
+      end
+    end
+  end
+end

data/spec/spec/mocks/double_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "double" do
+  it "is an alias for stub and mock" do
+    double().should be_a(Spec::Mocks::Mock)
+  end
+  
+  it "uses 'Double' in failure messages" do
+    double = double('name')
+    expect {double.foo}.to raise_error(/Double "name" received/)
+  end
+end