rspec 0.8.2 → 0.9.0

data/spec/spec/mocks/multiple_return_value_spec.rb

@@ -2,110 +2,110 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 module Spec
   module Mocks
-    context "a Mock expectation with multiple return values and no specified count" do
-      setup do
+    describe "a Mock expectation with multiple return values and no specified count" do
+      before(:each) do
         @mock = Mock.new("mock")
         @return_values = ["1",2,Object.new]
         @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2])
       end
       
-      specify "should return values in order to consecutive calls" do
-        @mock.message.should_eql @return_values[0]
-        @mock.message.should_eql @return_values[1]
-        @mock.message.should_eql @return_values[2]
-        @mock.__verify
+      it "should return values in order to consecutive calls" do
+        @mock.message.should == @return_values[0]
+        @mock.message.should == @return_values[1]
+        @mock.message.should == @return_values[2]
+        @mock.rspec_verify
       end
 
-      specify "should complain when there are too few calls" do
+      it "should complain when there are too few calls" do
         third = Object.new
-        @mock.message.should_eql @return_values[0]
-        @mock.message.should_eql @return_values[1]
-        lambda { @mock.__verify }.should_raise MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice"
+        @mock.message.should == @return_values[0]
+        @mock.message.should == @return_values[1]
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
       end
 
-      specify "should complain when there are too many calls" do
+      it "should complain when there are too many calls" do
         third = Object.new
-        @mock.message.should_eql @return_values[0]
-        @mock.message.should_eql @return_values[1]
-        @mock.message.should_eql @return_values[2]
-        @mock.message.should_eql @return_values[2]
-        lambda { @mock.__verify }.should_raise MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times"
+        @mock.message.should == @return_values[0]
+        @mock.message.should == @return_values[1]
+        @mock.message.should == @return_values[2]
+        @mock.message.should == @return_values[2]
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
       end
     end
 
-    context "a Mock expectation with multiple return values with a specified count equal to the number of values" do
-      setup do
+    describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do
+      before(:each) do
         @mock = Mock.new("mock")
         @return_values = ["1",2,Object.new]
         @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
       end
 
-      specify "should return values in order to consecutive calls" do
-        @mock.message.should_eql @return_values[0]
-        @mock.message.should_eql @return_values[1]
-        @mock.message.should_eql @return_values[2]
-        @mock.__verify
+      it "should return values in order to consecutive calls" do
+        @mock.message.should == @return_values[0]
+        @mock.message.should == @return_values[1]
+        @mock.message.should == @return_values[2]
+        @mock.rspec_verify
       end
 
-      specify "should complain when there are too few calls" do
+      it "should complain when there are too few calls" do
         third = Object.new
-        @mock.message.should_eql @return_values[0]
-        @mock.message.should_eql @return_values[1]
-        lambda { @mock.__verify }.should_raise MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice"
+        @mock.message.should == @return_values[0]
+        @mock.message.should == @return_values[1]
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
       end
 
-      specify "should complain when there are too many calls" do
+      it "should complain when there are too many calls" do
         third = Object.new
-        @mock.message.should_eql @return_values[0]
-        @mock.message.should_eql @return_values[1]
-        @mock.message.should_eql @return_values[2]
-        @mock.message.should_eql @return_values[2]
-        lambda { @mock.__verify }.should_raise MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times"
+        @mock.message.should == @return_values[0]
+        @mock.message.should == @return_values[1]
+        @mock.message.should == @return_values[2]
+        @mock.message.should == @return_values[2]
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
       end
     end
 
-    context "a Mock expectation with multiple return values specifying at_least less than the number of values" do
-      setup do
+    describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
+      before(:each) do
         @mock = Mock.new("mock")
         @mock.should_receive(:message).at_least(:twice).with(:no_args).and_return(11, 22)
       end
       
-      specify "should use last return value for subsequent calls" do
+      it "should use last return value for subsequent calls" do
         @mock.message.should equal(11)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should fail when called less than the specified number" do
+      it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
-        lambda { @mock.__verify }.should_raise MockExpectationError, "Mock 'mock' expected :message with (no args) twice, but received it once"
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (no args) twice, but received it once")
       end
     end
-    context "a Mock expectation with multiple return values with a specified count larger than the number of values" do
-      setup do
+    describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
+      before(:each) do
         @mock = Mock.new("mock")
         @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
       end
       
-      specify "should use last return value for subsequent calls" do
+      it "should use last return value for subsequent calls" do
         @mock.message.should equal(11)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should fail when called less than the specified number" do
+      it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
-        lambda { @mock.__verify }.should_raise MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it once"
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it once")
       end
 
-      specify "should fail when called greater than the specified number" do
+      it "should fail when called greater than the specified number" do
         @mock.message.should equal(11)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
-        lambda { @mock.__verify }.should_raise MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times"
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
       end
     end
   end

data/spec/spec/mocks/null_object_mock_spec.rb

@@ -2,35 +2,35 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    context "a mock acting as a NullObject" do
-      setup do
+    describe "a mock acting as a NullObject" do
+      before(:each) do
         @mock = Mock.new("null_object", :null_object => true)
       end
 
-      specify "should allow explicit expectation" do
+      it "should allow explicit expectation" do
         @mock.should_receive(:something)
         @mock.something
       end
 
-      specify "should fail verification when explicit exception not met" do
+      it "should fail verification when explicit exception not met" do
         lambda do
           @mock.should_receive(:something)
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
 
-      specify "should ignore unexpected methods" do
+      it "should ignore unexpected methods" do
         @mock.random_call("a", "d", "c")
-        @mock.__verify
+        @mock.rspec_verify
       end
 
-      specify "should expected message with different args first" do
+      it "should expected message with different args first" do
         @mock.should_receive(:message).with(:expected_arg)
         @mock.message(:unexpected_arg)
         @mock.message(:expected_arg)
       end
 
-      specify "should expected message with different args second" do
+      it "should expected message with different args second" do
         @mock.should_receive(:message).with(:expected_arg)
         @mock.message(:expected_arg)
         @mock.message(:unexpected_arg)

data/spec/spec/mocks/once_counts_spec.rb

@@ -1,56 +1,53 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
-module Mocks
-context "OnceCounts" do
-    setup do
-        @mock = Mock.new("test mock", {
-          :auto_verify => false
-        })
-      
-    end
-    specify "once should fail when called once with wrong args" do
+  module Mocks
+    describe "OnceCounts" do
+      before(:each) do
+        @mock = mock("test mock")
+      end
+
+      it "once should fail when called once with wrong args" do
         @mock.should_receive(:random_call).once.with("a", "b", "c")
         lambda do
           @mock.random_call("d", "e", "f")
-        end.should_raise(MockExpectationError)
-      
-    end
-    specify "once should fail when called twice" do
+        end.should raise_error(MockExpectationError)
+        @mock.rspec_reset
+      end
+
+      it "once should fail when called twice" do
         @mock.should_receive(:random_call).once
         @mock.random_call
         @mock.random_call
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
       
-    end
-    specify "once should fail when not called" do
+      it "once should fail when not called" do
         @mock.should_receive(:random_call).once
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
-      
-    end
-    specify "once should pass when called once" do
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
+
+      it "once should pass when called once" do
         @mock.should_receive(:random_call).once
         @mock.random_call
-        @mock.__verify
-      
-    end
-    specify "once should pass when called once with specified args" do
+        @mock.rspec_verify
+      end
+
+      it "once should pass when called once with specified args" do
         @mock.should_receive(:random_call).once.with("a", "b", "c")
         @mock.random_call("a", "b", "c")
-        @mock.__verify
-      
-    end
-    specify "once should pass when called once with unspecified args" do
+        @mock.rspec_verify
+      end
+
+      it "once should pass when called once with unspecified args" do
         @mock.should_receive(:random_call).once
         @mock.random_call("a", "b", "c")
-        @mock.__verify
-      
+        @mock.rspec_verify
+      end
     end
-  
-end
-end
+  end
 end

data/spec/spec/mocks/options_hash_spec.rb

@@ -2,29 +2,31 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    context "calling :should_receive with an options hash" do
-      specify "should report the file and line submitted with :expected_from" do
-        spec = Spec::Runner::Specification.new "spec" do
+    describe "calling :should_receive with an options hash" do
+      it "should report the file and line submitted with :expected_from" do
+        spec = Spec::DSL::Example.new "spec" do
           mock = Spec::Mocks::Mock.new("a mock")
           mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
+          mock.rspec_verify
         end
         reporter = mock("reporter", :null_object => true)
-        reporter.should_receive(:spec_finished) do |spec, error|
-          error.backtrace.detect {|line| line =~ /\/path\/to\/blah.ext:37/}.should_not_be nil
+        reporter.should_receive(:example_finished) do |spec, error|
+          error.backtrace.detect {|line| line =~ /\/path\/to\/blah.ext:37/}.should_not be_nil
         end
-        spec.run(reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+        spec.run(reporter, nil, nil, nil, Object.new)
       end
 
-      specify "should use the message supplied with :message" do
-        spec = Spec::Runner::Specification.new "spec" do
+      it "should use the message supplied with :message" do
+        spec = Spec::DSL::Example.new "spec" do
           mock = Spec::Mocks::Mock.new("a mock")
           mock.should_receive(:message, :message => "recebi nada")
+          mock.rspec_verify
         end
         reporter = mock("reporter", :null_object => true)
-        reporter.should_receive(:spec_finished) do |spec, error|
+        reporter.should_receive(:example_finished) do |spec, error|
           error.message.should == "recebi nada"
         end
-        spec.run(reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+        spec.run(reporter, nil, nil, nil, Object.new)
       end
     end
   end

data/spec/spec/mocks/partial_mock_spec.rb

@@ -2,49 +2,49 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    context "using a Partial Mock," do
-      setup do
+    describe "using a Partial Mock," do
+      before(:each) do
         @object = Object.new
       end
       
-      specify "should_not_receive should mock out the method" do
+      it "should_not_receive should mock out the method" do
         @object.should_not_receive(:fuhbar)
         @object.fuhbar
         lambda do
-          @object.__verify
-        end.should_raise(Spec::Mocks::MockExpectationError)
+          @object.rspec_verify
+        end.should raise_error(Spec::Mocks::MockExpectationError)
       end
 
-      specify "should_not_receive should return a negative message expectation" do
-        @object.should_not_receive(:foobar).should_be_kind_of(NegativeMessageExpectation)
+      it "should_not_receive should return a negative message expectation" do
+        @object.should_not_receive(:foobar).should be_kind_of(NegativeMessageExpectation)
       end
 
-      specify "should_receive should mock out the method" do
+      it "should_receive should mock out the method" do
         @object.should_receive(:foobar).with(:test_param).and_return(1)
         @object.foobar(:test_param).should equal(1)
       end
 
-      specify "should_receive should handle a hash" do
+      it "should_receive should handle a hash" do
         @object.should_receive(:foobar).with(:key => "value").and_return(1)
         @object.foobar(:key => "value").should equal(1)
       end
 
-      specify "should_receive should handle an inner hash" do
+      it "should_receive should handle an inner hash" do
         hash = {:a => {:key => "value"}}
         @object.should_receive(:foobar).with(:key => "value").and_return(1)
         @object.foobar(hash[:a]).should equal(1)
       end
 
-      specify "should_receive should return a message expectation" do
-        @object.should_receive(:foobar).should_be_kind_of(MessageExpectation)
+      it "should_receive should return a message expectation" do
+        @object.should_receive(:foobar).should be_kind_of(MessageExpectation)
         @object.foobar
       end
 
-      specify "should_receive should verify method was called" do
+      it "should_receive should verify method was called" do
         @object.should_receive(:foobar).with(:test_param).and_return(1)
         lambda do
-          @object.__verify
-        end.should_raise(Spec::Mocks::MockExpectationError)
+          @object.rspec_verify
+        end.should raise_error(Spec::Mocks::MockExpectationError)
       end
 
     end

data/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -2,8 +2,8 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
 module Mocks
-context "PartialMockUsingMocksDirectly" do
-    setup do
+describe "PartialMockUsingMocksDirectly" do
+    before(:each) do
       
         klass=Class.new
         klass.class_eval do
@@ -14,47 +14,49 @@ context "PartialMockUsingMocksDirectly" do
         @obj = klass.new
       
     end
-    specify "should clear expectations on verify" do
-        @obj.should_receive(:msg)
-        @obj.msg
-        @obj.__verify
-        lambda do
-          @obj.msg
-        end.should_raise(NoMethodError)
-      
-    end
-    specify "should fail when expected message is not received" do
+    
+    # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149
+    # specify "should clear expectations on verify" do
+    #     @obj.should_receive(:msg)
+    #     @obj.msg
+    #     @obj.rspec_verify
+    #     lambda do
+    #       @obj.msg
+    #     end.should raise_error(NoMethodError)
+    #   
+    # end
+    it "should fail when expected message is not received" do
         @obj.should_receive(:msg)
         lambda do
-          @obj.__verify
-        end.should_raise(MockExpectationError)
+          @obj.rspec_verify
+        end.should raise_error(MockExpectationError)
       
     end
-    specify "should fail when message is received with incorrect args" do
+    it "should fail when message is received with incorrect args" do
         @obj.should_receive(:msg).with(:correct_arg)
         lambda do
           @obj.msg(:incorrect_arg)
-        end.should_raise(MockExpectationError)
+        end.should raise_error(MockExpectationError)
         @obj.msg(:correct_arg)
       
     end
-    specify "should pass when expected message is received" do
+    it "should pass when expected message is received" do
         @obj.should_receive(:msg)
         @obj.msg
-        @obj.__verify
+        @obj.rspec_verify
       
     end
-    specify "should pass when message is received with correct args" do
+    it "should pass when message is received with correct args" do
         @obj.should_receive(:msg).with(:correct_arg)
         @obj.msg(:correct_arg)
-        @obj.__verify
+        @obj.rspec_verify
       
     end
-    specify "should revert to original method if existed" do
+    it "should revert to original method if existed" do
         @obj.existing_method.should equal(:original_value)
         @obj.should_receive(:existing_method).and_return(:mock_value)
         @obj.existing_method.should equal(:mock_value)
-        @obj.__verify
+        @obj.rspec_verify
         @obj.existing_method.should equal(:original_value)
       
     end