rspec 0.8.2 → 0.9.0

data/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -2,88 +2,88 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    context "a mock, in handling arguments" do
-      setup do
+    describe "a mock, in handling arguments" do
+      before(:each) do
         @mock = Mock.new("test mock")
       end
       
-      teardown do
-        @mock.__verify
+      after(:each) do
+        @mock.rspec_verify
       end
 
-      specify "should accept true as boolean" do
+      it "should accept true as boolean" do
         @mock.should_receive(:random_call).with(:boolean)
         @mock.random_call(true)
       end
       
-      specify "should accept false as boolean" do
+      it "should accept false as boolean" do
         @mock.should_receive(:random_call).with(:boolean)
         @mock.random_call(false)
       end
 
-      specify "should accept fixnum as numeric" do
+      it "should accept fixnum as numeric" do
         @mock.should_receive(:random_call).with(:numeric)
         @mock.random_call(1)
       end
 
-      specify "should accept float as numeric" do
+      it "should accept float as numeric" do
         @mock.should_receive(:random_call).with(:numeric)
         @mock.random_call(1.5)
       end
 
-      specify "should accept string as anything" do
+      it "should accept string as anything" do
         @mock.should_receive(:random_call).with("a", :anything, "c")
         @mock.random_call("a", "whatever", "c")
       end
 
-      specify "should match duck type with one method" do
+      it "should match duck type with one method" do
         @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:length))
         @mock.random_call([])
       end
 
-      specify "should match duck type with two methods" do
+      it "should match duck type with two methods" do
         @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
         @mock.random_call(1)
       end
 
-      specify "should match non special symbol" do
+      it "should match non special symbol" do
         @mock.should_receive(:random_call).with(:some_symbol)
         @mock.random_call(:some_symbol)
       end
 
-      specify "should match string" do
+      it "should match string" do
         @mock.should_receive(:random_call).with(:string)
         @mock.random_call("a string")
       end
 
-      specify "should match string against regexp" do
+      it "should match string against regexp" do
         @mock.should_receive(:random_call).with(/bcd/)
         @mock.random_call("abcde")
       end
 
-      specify "should match regexp against regexp" do
+      it "should match regexp against regexp" do
         @mock.should_receive(:random_call).with(/bcd/)
         @mock.random_call(/bcd/)
       end
       
-      specify "should match against a hash submitted and received by value" do
+      it "should match against a hash submitted and received by value" do
         @mock.should_receive(:random_call).with(:a => "a", :b => "b")
         @mock.random_call(:a => "a", :b => "b")
       end
       
-      specify "should match against a hash submitted by reference and received by value" do
+      it "should match against a hash submitted by reference and received by value" do
         opts = {:a => "a", :b => "b"}
         @mock.should_receive(:random_call).with(opts)
         @mock.random_call(:a => "a", :b => "b")
       end
       
-      specify "should match against a hash submitted by value and received by reference" do
+      it "should match against a hash submitted by value and received by reference" do
         opts = {:a => "a", :b => "b"}
         @mock.should_receive(:random_call).with(:a => "a", :b => "b")
         @mock.random_call(opts)
       end
       
-      specify "should match against a Matcher" do
+      it "should match against a Matcher" do
         @mock.should_receive(:msg).with(equal(37))
         @mock.msg(37)
       end

data/spec/spec/mocks/precise_counts_spec.rb

@@ -1,56 +1,52 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
-module Mocks
-context "PreciseCounts" do
-    setup do
-        @mock = Mock.new("test mock", {
-          :auto_verify => false
-        })
-      
-    end
-    specify "should fail when exactly n times method is called less than n times" do
+  module Mocks
+    describe "PreciseCounts" do
+      before(:each) do
+        @mock = mock("test mock")
+      end
+
+      it "should fail when exactly n times method is called less than n times" do
         @mock.should_receive(:random_call).exactly(3).times
         @mock.random_call
         @mock.random_call
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
-      
-    end
-    specify "should fail when exactly n times method is never called" do
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
+
+      it "should fail when exactly n times method is never called" do
         @mock.should_receive(:random_call).exactly(3).times
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
-      
-    end
-    specify "should pass if exactly n times method is called exactly n times" do
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
+      end
+
+      it "should pass if exactly n times method is called exactly n times" do
         @mock.should_receive(:random_call).exactly(3).times
         @mock.random_call
         @mock.random_call
         @mock.random_call
-        @mock.__verify
-      
-    end
-    specify "should pass multiple calls with different args and counts" do
+        @mock.rspec_verify
+      end
+
+      it "should pass multiple calls with different args and counts" do
         @mock.should_receive(:random_call).twice.with(1)
         @mock.should_receive(:random_call).once.with(2)
         @mock.random_call(1)
         @mock.random_call(2)
         @mock.random_call(1)
-        @mock.__verify
-      
-    end
-    specify "should pass mutiple calls with different args" do
+        @mock.rspec_verify
+      end
+
+      it "should pass mutiple calls with different args" do
         @mock.should_receive(:random_call).once.with(1)
         @mock.should_receive(:random_call).once.with(2)
         @mock.random_call(1)
         @mock.random_call(2)
-        @mock.__verify
-      
+        @mock.rspec_verify
+      end
     end
-  
-end
-end
+  end
 end

data/spec/spec/mocks/record_messages_spec.rb

@@ -2,24 +2,24 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 module Spec
   module Mocks
-    context "a mock" do
-      setup do
+    describe "a mock" do
+      before(:each) do
         @mock = mock("mock", :null_object => true)
       end
-      specify "should answer false for received_message? when no messages received" do
-        @mock.received_message?(:message).should be(false)
+      it "should answer false for received_message? when no messages received" do
+        @mock.received_message?(:message).should be_false
       end
-      specify "should answer true for received_message? when message received" do
+      it "should answer true for received_message? when message received" do
         @mock.message
-        @mock.received_message?(:message).should be(true)
+        @mock.received_message?(:message).should be_true
       end
-      specify "should answer true for received_message? when message received with correct args" do
+      it "should answer true for received_message? when message received with correct args" do
         @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2,3).should be(true)
+        @mock.received_message?(:message, 1,2,3).should be_true
       end
-      specify "should answer false for received_message? when message received with incorrect args" do
+      it "should answer false for received_message? when message received with incorrect args" do
         @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2).should be(false)
+        @mock.received_message?(:message, 1,2).should be_false
       end
     end
   end

data/spec/spec/mocks/stub_spec.rb

@@ -2,8 +2,8 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    context "A method stub" do
-      setup do
+    describe "A method stub" do
+      before(:each) do
         @class = Class.new do
           def self.existing_class_method
             :original_value
@@ -16,88 +16,88 @@ module Spec
         @obj = @class.new
       end
 
-      specify "should allow for a mock expectation to temporarily replace a method stub on a mock" do
+      it "should allow for a mock expectation to temporarily replace a method stub on a mock" do
         mock = Spec::Mocks::Mock.new("a mock")
         mock.stub!(:msg).and_return(:stub_value)
         mock.should_receive(:msg).with(:arg).and_return(:mock_value)
         mock.msg(:arg).should equal(:mock_value)
         mock.msg.should equal(:stub_value)
         mock.msg.should equal(:stub_value)
-        mock.__verify
+        mock.rspec_verify
       end
 
-      specify "should allow for a mock expectation to temporarily replace a method stub on a non-mock" do
+      it "should allow for a mock expectation to temporarily replace a method stub on a non-mock" do
         @obj.stub!(:msg).and_return(:stub_value)
         @obj.should_receive(:msg).with(:arg).and_return(:mock_value)
         @obj.msg(:arg).should equal(:mock_value)
         @obj.msg.should equal(:stub_value)
         @obj.msg.should equal(:stub_value)
-        @obj.__verify
+        @obj.rspec_verify
       end
 
-      specify "should ignore when expected message is not received" do
+      it "should ignore when expected message is not received" do
         @obj.stub!(:msg)
         lambda do
-          @obj.__verify
-        end.should_not_raise
+          @obj.rspec_verify
+        end.should_not raise_error
       end
       
-      specify "should clear itself on __verify" do
+      it "should clear itself on rspec_verify" do
         @obj.stub!(:this_should_go).and_return(:blah)
-        @obj.this_should_go.should_equal :blah
-        @obj.__verify
+        @obj.this_should_go.should == :blah
+        @obj.rspec_verify
         lambda do
           @obj.this_should_go
-        end.should_raise
+        end.should raise_error
       end
 
-      specify "should ignore when expected message is received" do
+      it "should ignore when expected message is received" do
         @obj.stub!(:msg)
         @obj.msg
-        @obj.__verify
+        @obj.rspec_verify
       end
 
-      specify "should ignore when message is received with args" do
+      it "should ignore when message is received with args" do
         @obj.stub!(:msg)
         @obj.msg(:an_arg)
-        @obj.__verify
+        @obj.rspec_verify
       end
 
-      specify "should not support with" do
+      it "should not support with" do
         lambda do
           Spec::Mocks::Mock.new("a mock").stub!(:msg).with(:arg)
-        end.should_raise(NoMethodError)
+        end.should raise_error(NoMethodError)
       end
       
-      specify "should return expected value when expected message is received" do
+      it "should return expected value when expected message is received" do
         @obj.stub!(:msg).and_return(:return_value)
         @obj.msg.should equal(:return_value)
-        @obj.__verify
+        @obj.rspec_verify
       end
 
-      specify "should return values in order to consecutive calls" do
+      it "should return values in order to consecutive calls" do
         return_values = ["1",2,Object.new]
         @obj.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
-        @obj.msg.should_eql return_values[0]
-        @obj.msg.should_eql return_values[1]
-        @obj.msg.should_eql return_values[2]
+        @obj.msg.should == return_values[0]
+        @obj.msg.should == return_values[1]
+        @obj.msg.should == return_values[2]
       end
 
-      specify "should keep returning last value in consecutive calls" do
+      it "should keep returning last value in consecutive calls" do
         return_values = ["1",2,Object.new]
         @obj.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
-        @obj.msg.should_eql return_values[0]
-        @obj.msg.should_eql return_values[1]
-        @obj.msg.should_eql return_values[2]
-        @obj.msg.should_eql return_values[2]
-        @obj.msg.should_eql return_values[2]
+        @obj.msg.should == return_values[0]
+        @obj.msg.should == return_values[1]
+        @obj.msg.should == return_values[2]
+        @obj.msg.should == return_values[2]
+        @obj.msg.should == return_values[2]
       end
 
-      specify "should revert to original instance method if existed" do
+      it "should revert to original instance method if existed" do
         @obj.existing_instance_method.should equal(:original_value)
         @obj.stub!(:existing_instance_method).and_return(:mock_value)
         @obj.existing_instance_method.should equal(:mock_value)
-        @obj.__verify
+        @obj.rspec_verify
         # TODO JRUBY: This causes JRuby to fail with:
         # NativeException in 'Stub should revert to original instance method if existed'
         # java.lang.ArrayIndexOutOfBoundsException: 0
@@ -118,39 +118,39 @@ module Spec
         @obj.existing_instance_method.should equal(:original_value)
       end
       
-      specify "should revert to original class method if existed" do
+      it "should revert to original class method if existed" do
         @class.existing_class_method.should equal(:original_value)
         @class.stub!(:existing_class_method).and_return(:mock_value)
         @class.existing_class_method.should equal(:mock_value)
-        @class.__verify
+        @class.rspec_verify
         @class.existing_class_method.should equal(:original_value)
       end
 
-      specify "should clear itself on __verify" do
+      it "should clear itself on rspec_verify" do
         @obj.stub!(:this_should_go).and_return(:blah)
-        @obj.this_should_go.should_equal :blah
-        @obj.__verify
+        @obj.this_should_go.should == :blah
+        @obj.rspec_verify
         lambda do
           @obj.this_should_go
-        end.should_raise
+        end.should raise_error
       end
       
-      specify "should support yielding" do
+      it "should support yielding" do
         @obj.stub!(:method_that_yields).and_yield(:yielded_value)
         current_value = :value_before
         @obj.method_that_yields {|val| current_value = val}
-        current_value.should_equal :yielded_value
-        @obj.__verify
+        current_value.should == :yielded_value
+        @obj.rspec_verify
       end
 
-      specify "should throw when told to" do
+      it "should throw when told to" do
         @mock.stub!(:something).and_throw(:blech)
         lambda do
           @mock.something
-        end.should_throw(:blech)
+        end.should throw_symbol(:blech)
       end
       
-      specify "should support overriding w/ a new stub" do
+      it "should support overriding w/ a new stub" do
         @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
         @stub.existing_instance_method.should == :updated_stub_value
       end

data/spec/spec/mocks/twice_counts_spec.rb

@@ -2,65 +2,65 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Mocks
-    context "TwiceCounts" do
-      setup do
-        @mock = Mock.new("test mock", {
-          :auto_verify => false
-        })
+    describe "TwiceCounts" do
+      before(:each) do
+        @mock = mock("test mock")
       end
 
-      specify "twice should fail when call count is higher than expected" do
+      it "twice should fail when call count is higher than expected" do
         @mock.should_receive(:random_call).twice
         @mock.random_call
         @mock.random_call
         @mock.random_call
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
       
-      specify "twice should fail when call count is lower than expected" do
+      it "twice should fail when call count is lower than expected" do
         @mock.should_receive(:random_call).twice
         @mock.random_call
         lambda do
-          @mock.__verify
-        end.should_raise(MockExpectationError)
+          @mock.rspec_verify
+        end.should raise_error(MockExpectationError)
       end
       
-      specify "twice should fail when called twice with wrong args on the first call" do
+      it "twice should fail when called twice with wrong args on the first call" do
         @mock.should_receive(:random_call).twice.with("1", 1)
         lambda do
           @mock.random_call(1, "1")
-        end.should_raise(MockExpectationError)
+        end.should raise_error(MockExpectationError)
+        @mock.rspec_reset
       end
       
-      specify "twice should fail when called twice with wrong args on the second call" do
+      it "twice should fail when called twice with wrong args on the second call" do
         @mock.should_receive(:random_call).twice.with("1", 1)
         @mock.random_call("1", 1)
         lambda do
           @mock.random_call(1, "1")
-        end.should_raise(MockExpectationError)
+        end.should raise_error(MockExpectationError)
+        @mock.rspec_reset
       end
       
-      specify "twice should pass when called twice" do
+      it "twice should pass when called twice" do
         @mock.should_receive(:random_call).twice
         @mock.random_call
         @mock.random_call
-        @mock.__verify
+        @mock.rspec_verify
       end
       
-      specify "twice should pass when called twice with specified args" do
+      it "twice should pass when called twice with specified args" do
         @mock.should_receive(:random_call).twice.with("1", 1)
         @mock.random_call("1", 1)
         @mock.random_call("1", 1)
-        @mock.__verify
+        @mock.rspec_verify
       end
       
-      specify "twice should pass when called twice with unspecified args" do
+      it "twice should pass when called twice with unspecified args" do
         @mock.should_receive(:random_call).twice
         @mock.random_call("1")
         @mock.random_call(1)
-        @mock.__verify
+        @mock.rspec_verify
       end
     end
   end