rspec 0.5.12 → 0.5.13

data/test/spec/api/helper/regex_matching_test.rb

@@ -3,31 +3,29 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Spec
   module Api
     module Helper
-      class RegexMatchingTest < Test::Unit::TestCase
+      class ShouldMatchTest < Test::Unit::TestCase
 
-      # should.match
-
-        def test_should_match_should_not_raise_when_objects_match
+        def test_should_not_raise_when_objects_match
           assert_nothing_raised do
             "hi aslak".should.match /aslak/
           end
         end
 
-        def test_should_equal_should_raise_when_objects_do_not_match
+        def test_should_raise_when_objects_do_not_match
           assert_raise(ExpectationNotMetError) do
             "hi aslak".should.match /steve/
           end
         end
+      end
 
-        # should.not.match
-
-        def test_should_not_match_should_not_raise_when_objects_do_not_match
+      class ShouldNotMatchTest < Test::Unit::TestCase
+        def test_should_not_raise_when_objects_do_not_match
           assert_nothing_raised do
             "hi aslak".should.not.match /steve/
           end
         end
 
-        def test_should_not_match_should_raise_when_objects_match
+        def test_should_raise_when_objects_match
           assert_raise(ExpectationNotMetError) do
             "hi aslak".should.not.match /aslak/
           end

data/test/spec/api/helper/throwing_test.rb

@@ -3,49 +3,48 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Spec
   module Api
     module Helper
-      class ThrowingTest < Test::Unit::TestCase
+      class ShouldThrowTest < Test::Unit::TestCase
 
-        # should.raise
-  
-        def test_should_throw_should_pass_when_proper_symbol_is_thrown
+        def test_should_pass_when_proper_symbol_is_thrown
           assert_nothing_raised do
             proc { throw :foo }.should.throw :foo
           end
         end
   
-        def test_should_throw_should_fail_when_wrong_exception_is_thrown
+        def test_should_fail_when_wrong_symbol_is_thrown
           assert_raise(ExpectationNotMetError) do
             proc { throw :bar }.should.throw :foo
           end
         end
    
-        def test_should_throw_should_fail_when_no_symbol_is_thrown
+        def test_should_fail_when_no_symbol_is_thrown
           assert_raise(ExpectationNotMetError) do
-            proc {''.to_s}.should.throw :foo
+            proc { ''.to_s }.should.throw :foo
           end
         end
+      end
 
-        # should.not.throw
+      class ShouldNotThrowTest < Test::Unit::TestCase
 
-        def test_should_not_throw_should_fail_when_specific_symbol_is_thrown
+        def test_should_fail_when_expected_symbol_is_actually_thrown
           assert_raise(ExpectationNotMetError) do
             proc { throw :foo }.should.not.throw :foo
           end
         end
 
-        def test_should_not_throw_should_pass_when_other_symbol_is_thrown
+        def test_should_pass_when_expected_symbol_is_thrown
           assert_nothing_raised do
             proc { throw :bar }.should.not.throw :foo
           end
         end
 
-        def test_should_not_throw_should_pass_when_no_symbol_is_thrown
+        def test_should_pass_when_no_symbol_is_thrown
           assert_nothing_raised do
             proc { ''.to_s }.should.not.throw :foo
           end
         end
 
-        def test_should_not_throw_should_pass_when_no_symbol_is_thrown_and_none_is_specified
+        def test_should_pass_when_no_symbol_is_thrown_and_none_is_specified
           assert_nothing_raised do
             proc { ''.to_s }.should.not.throw
           end

data/test/spec/api/helper/true_false_special_case_test.rb

@@ -3,79 +3,77 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Spec
   module Api
     module Helper
-      class TrueFalseSpecialCaseTest < Test::Unit::TestCase
+      class ShouldBeTrueTest < Test::Unit::TestCase
 
-        # should.be true
-  
-        def test_should_be_true_should_raise_when_object_is_nil
+        def test_should_raise_when_object_is_nil
           assert_raise(ExpectationNotMetError) do
             nil.should.be true
           end
         end
   
-        def test_should_be_true_should_raise_when_object_is_false
+        def test_should_raise_when_object_is_false
           assert_raise(ExpectationNotMetError) do
             false.should.be true
           end
         end
 
-        def test_should_be_true_shouldnt_raise_when_object_is_true
+        def test_shouldnt_raise_when_object_is_true
           assert_nothing_raised do
             true.should.be true
           end
         end
 
-        def test_should_be_true_shouldnt_raise_when_object_is_a_number
+        def test_shouldnt_raise_when_object_is_a_number
           assert_nothing_raised do
             5.should.be true
           end
         end
   
-        def test_should_be_true_shouldnt_raise_when_object_is_a_string
+        def test_shouldnt_raise_when_object_is_a_string
           assert_nothing_raised do
             "hello".should.be true
           end
         end
 
-        def test_should_be_true_shouldnt_raise_when_object_is_a_some_random_object
+        def test_shouldnt_raise_when_object_is_a_some_random_object
           assert_nothing_raised do
             self.should.be true
           end
         end
+      end
 
-        # should.be false
-
-        def test_should_be_false_shouldnt_raise_when_object_is_nil
+      class ShouldBeFalseTest < Test::Unit::TestCase
+        def test_shouldnt_raise_when_object_is_nil
           assert_nothing_raised do
             nil.should.be false
           end
         end
 
-        def test_should_be_false_shouldnt_raise_when_object_is_false
+        def test_shouldnt_raise_when_object_is_false
           assert_nothing_raised do
             false.should.be false
           end
         end
 
-        def test_should_be_false_should_raise_when_object_is_true
+        def test_should_raise_when_object_is_true
           assert_raise(ExpectationNotMetError) do
             true.should.be false
           end
         end
 
-        def test_should_be_false_shouldnt_raise_when_object_is_a_number
+        def test_shouldnt_raise_when_object_is_a_number
           assert_raise(ExpectationNotMetError) do
             5.should.be false
           end
         end
 
-        def test_should_be_false_shouldnt_raise_when_object_is_a_string
+        def test_shouldnt_raise_when_object_is_a_string
           assert_raise(ExpectationNotMetError) do
             "hello".should.be false
           end
         end
 
-        def test_should_be_false_shouldnt_raise_when_object_is_a_some_random_object
+        def test_shouldnt_raise_when_object_is_a_some_random_object
           assert_raise(ExpectationNotMetError) do
             self.should.be false
           end

data/test/spec/api/helper/typing_test.rb

@@ -3,99 +3,100 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Spec
   module Api
     module Helper
-      class TypeTest < Test::Unit::TestCase
+      class ShouldBeAnInstanceOfTest < Test::Unit::TestCase
 
-        # should.be.an.instance.of <class>
-  
-        def test_should_be_an_instance_of_should_pass_when_target_is_specified_class
+        def test_should_pass_when_target_is_specified_class
           assert_nothing_raised do
             5.should.be.an.instance.of Fixnum
           end
         end
   
-        def test_should_be_an_instance_of_should_fail_when_target_is_not_specified_class
+        def test_should_fail_when_target_is_not_specified_class
           assert_raise(ExpectationNotMetError) do
             5.should.be.an.instance.of Integer
           end
         end
+      end
+
+      class ShouldBeAKindOfTest < Test::Unit::TestCase
   
-        # should.be.a.kind.of <class>
-  
-        def test_should_be_a_kind_of_should_pass_when_target_is_of_specified_class
+        def test_should_pass_when_target_is_of_specified_class
           assert_nothing_raised do
             5.should.be.a.kind.of Fixnum
           end
         end
 
-        def test_should_be_a_kind_of_should_pass_when_target_is_of_subclass_of_specified_class
+        def test_should_pass_when_target_is_of_subclass_of_specified_class
           assert_nothing_raised do
             5.should.be.a.kind.of Integer
           end
         end
 
-        def test_should_be_an_instance_of_should_fail_when_target_is_not_specified_class
+        def test_should_fail_when_target_is_not_specified_class
           assert_raise(ExpectationNotMetError) do
             5.should.be.a.kind.of String
           end
         end
+      end
+
+      class ShouldNotBeAnInstanceOfTest < Test::Unit::TestCase
   
-        # should.not.be.an.instance_of <class>
-  
-        def test_should_not_be_an_instance_of_should_fail_when_target_is_of_specified_class
+        def test_should_fail_when_target_is_of_specified_class
           assert_raise(ExpectationNotMetError) do
             'hello'.should.not.be.an.instance.of String
           end
         end
   
-        def test_should_be_an_instance_of_should_pass_when_target_is_not_of_specified_class
+        def test_should_pass_when_target_is_not_of_specified_class
           assert_nothing_raised do
             [].should.not.be.an.instance.of String
           end
         end
+      end
 
-        # should.be.a.kind.of <class>
+      class ShouldNotBeAKindOfTest < Test::Unit::TestCase
   
-        def test_should_not_be_a_kind_of_should_fail_when_target_is_of_specified_class
+        def test_should_fail_when_target_is_of_specified_class
           assert_raise(ExpectationNotMetError) do
             5.should.not.be.a.kind.of Fixnum
           end
         end
 
-        def test_should_not_be_a_kind_of_should_fail_when_target_is_of_subclass_of_specified_class
+        def test_should_fail_when_target_is_of_subclass_of_specified_class
           assert_raise(ExpectationNotMetError) do
             5.should.not.be.a.kind.of Integer
           end
         end
 
-        def test_should_not_be_an_instance_of_should_pass_when_target_is_not_specified_class
+        def test_should_pass_when_target_is_not_specified_class
           assert_nothing_raised do
             5.should.not.be.a.kind.of String
           end
         end
+      end
   
-        # should.respond.to <message>
-  
-        def test_should_respond_to_should_pass_when_target_does
+      class ShouldRespondToTest < Test::Unit::TestCase
+        def test_should_pass_when_target_responds_to
           assert_nothing_raised do
             "".should.respond.to :length
           end
         end
 
-        def test_should_respond_to_should_fail_when_target_doesnt
+        def test_should_fail_when_target_doesnt_respond_to
           assert_raise(ExpectationNotMetError) do
             "".should.respond.to :connect
           end
         end
+      end
 
-        # should.not.respond.to <message>
-  
-        def test_not_should_respond_to_should_fail_when_target_does
+      class ShouldNotRespondToTest < Test::Unit::TestCase
+        def test_should_fail_when_target_responds_to
           assert_raise(ExpectationNotMetError) do
             "".should.not.respond.to :length
           end
         end
 
-        def test_not_should_respond_to_should_pass_when_target_doesnt
+        def test_should_pass_when_target_doesnt_respond_to
           assert_nothing_raised do
             "".should.not.respond.to :connect
           end

data/test/spec/api/mocks/mock_arg_constraints_test.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 
 module Spec
   module Api
-    class PassingConstraintsTest < Test::Unit::TestCase
+    class PassingConstraintsToMockTest < Test::Unit::TestCase
       
       def setup
         @mock = Mock.new("test mock")

data/test/spec/api/mocks/mock_test.rb

@@ -23,7 +23,6 @@ module Spec
       def test_should_allow_block_to_calculate_return_values
         @mock.should.receive(:random_call).with("a","b","c").and.return { |a,b,c| c+b+a }
         assert_equal "cba", @mock.random_call("a","b","c")
-        # TODO: remove __verify when migrating to self-hosting. Verify happens transparently in teardown. (AH)
         @mock.__verify
       end
 
@@ -86,17 +85,17 @@ module Spec
       end
   
       def test_two_return_values
-        @mock.should.receive(:multi_call).twice.with(:no_args).and.return([1, 2])
-        assert_equal(1, @mock.multi_call)
-        assert_equal(2, @mock.multi_call)
+        @mock.should.receive(:multi_call).twice.with(:no_args).and.return([8, 12])
+        assert_equal(8, @mock.multi_call)
+        assert_equal(12, @mock.multi_call)
         @mock.__verify
       end
   
       def test_repeating_final_return_value
-        @mock.should.receive(:multi_call).at.least(:once).with(:no_args).and.return([1, 2])
-        assert_equal(1, @mock.multi_call)
-        assert_equal(2, @mock.multi_call)
-        assert_equal(2, @mock.multi_call)
+        @mock.should.receive(:multi_call).at.least(:once).with(:no_args).and.return([11, 22])
+        assert_equal(11, @mock.multi_call)
+        assert_equal(22, @mock.multi_call)
+        assert_equal(22, @mock.multi_call)
         @mock.__verify
       end
   
@@ -249,7 +248,7 @@ module Spec
           @mock.__verify
         end
       end
-      
+
       def test_should_raise_if_exactly_3_times_method_is_called_4_times
         @mock.should.receive(:random_call).exactly(3).times
         @mock.random_call
@@ -260,19 +259,34 @@ module Spec
         end
       end
 
-      def test_raising
+      def test_should_raise_when_told_to
         @mock.should.receive(:random_call).and.raise(RuntimeError)
         assert_raise(RuntimeError) do
           @mock.random_call
         end
       end
  
-      def test_throwing
+      def test_should_not_raise_when_told_to_if_args_dont_match
+        @mock.should.receive(:random_call).with(2).and.raise(RuntimeError)
+        assert_raise(MockExpectationError) do
+          @mock.random_call(1)
+        end
+      end
+ 
+      def test_should_throw_when_told_to
         @mock.should.receive(:random_call).and.throw(:blech)
         assert_throws(:blech) do
           @mock.random_call
         end
       end
+
+      def test_should_raise_when_explicit_return_and_block_constrained
+        assert_raise(AmbiguousReturnError) {
+          @mock.should.receive(:fruit){|colour|
+            :strawberry
+          }.and.return :apple
+        }
+      end
       
       def TODO_test_should_use_past_tense
         @mock.should.have.received(:hello)
@@ -308,6 +322,14 @@ module Spec
         @mock.__verify
       end
 
+      def test_should_yield_single_values
+        @mock.should.receive(:yield_back).with(:no_args).once.and.yield(99)
+        a = nil
+        @mock.yield_back {|a|}
+        a.should.equal 99
+        @mock.__verify
+      end
+
       def test_should_fail_when_calling_yielding_method_with_wrong_arity
         @mock.should.receive(:yield_back).with(:no_args).once.and.yield('wha', 'zup')
         assert_raise(MockExpectationError) do
@@ -328,6 +350,18 @@ module Spec
         @mock.__verify
       end
       
+      def test_should_be_able_to_raise_from_method_calling_yielding_mock
+        @mock.should.receive(:yield_me).and_yield 44
+        
+        lambda do
+          @mock.yield_me do |x|
+            raise "Bang"
+          end
+        end.should_raise(StandardError)
+
+        @mock.__verify
+      end
+
     end
   end
 end

data/test/spec/api/mocks/null_object_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Spec
   module Api
 
-    class NullObjectTest < Test::Unit::TestCase
+    class NullObjectMockTest < Test::Unit::TestCase
 
       def setup
         @mock = Mock.new("null_object", :null_object=>true)
@@ -14,13 +14,13 @@ module Spec
         @mock.__verify
       end 
     
-      def test_should_handle_passing_expectation
+      def test_should_allow_explicit_expectation
         @mock.should_receive(:something)
         @mock.something
         @mock.__verify
       end
       
-      def test_should_handle_failing_expectation
+      def test_should_fail_verification_when_explicit_exception_not_met
         assert_raises(MockExpectationError) do
           @mock.should_receive(:something)
           @mock.__verify