rspec 0.5.16 → 0.6.0

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

@@ -9,28 +9,79 @@ module Spec
         @mock = Mock.new("test mock")
       end
 
-      def test_two_in_order_calls
-        @mock.should.receive(:one).ordered
-        @mock.should.receive(:two).ordered
+      def test_should_pass_two_calls_in_order
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
         @mock.one
         @mock.two
         @mock.__verify
       end
 
-      def test_two_out_of_order_calls
-        @mock.should.receive(:one).ordered
-        @mock.should.receive(:two).ordered
+      def test_should_pass_three_calls_in_order
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        @mock.should_receive(:three).ordered
+        @mock.one
+        @mock.two
+        @mock.three
+        @mock.__verify
+      end
+
+      def test_should_fail_if_second_call_comes_first
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
         assert_raise(MockExpectationError) do
           @mock.two
         end
       end
+
+      def test_should_fail_if_third_call_comes_first
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        @mock.should_receive(:three).ordered
+        @mock.one
+        assert_raise(MockExpectationError) do
+          @mock.three
+        end
+      end
+      
+      def test_should_fail_if_third_call_comes_second
+        @mock.should_receive(:one).ordered
+        @mock.should_receive(:two).ordered
+        @mock.should_receive(:three).ordered
+        @mock.one
+        assert_raise(MockExpectationError) do
+          @mock.one
+          @mock.three
+        end
+      end
+
+      def test_should_ignore_order_of_non_ordered_calls
+        @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.__verify
+      end
       
       def FIXME_test_two_in_order_calls_with_block
-        @mock.should.receive(:doit).ordered do |a, b|
+        @mock.should_receive(:doit).ordered do |a, b|
           a.should_equal "a1"
           a.should_equal "b1"
         end
-        @mock.should.receive(:doit).ordered do |a, b|
+        @mock.should_receive(:doit).ordered do |a, b|
           a.should_equal "a2"
           a.should_equal "b2"
         end
@@ -40,11 +91,11 @@ module Spec
       end
 
       def FIXME_test_two_out_of_order_calls_with_block
-        @mock.should.receive(:doit).ordered do |a, b|
+        @mock.should_receive(:doit).ordered do |a, b|
           a.should_equal "a1"
           a.should_equal "b1"
         end
-        @mock.should.receive(:doit).ordered do |a, b|
+        @mock.should_receive(:doit).ordered do |a, b|
           a.should_equal "a2"
           a.should_equal "b2"
         end
@@ -52,38 +103,6 @@ module Spec
         @mock.doit "a1", "b1"
         @mock.__verify
       end
-
-      def test_three_linear_calls
-        @mock.should.receive(:one).ordered
-        @mock.should.receive(:two).ordered
-        @mock.should.receive(:three).ordered
-        @mock.one
-        @mock.two
-        @mock.three
-        @mock.__verify
-      end
-
-      def test_three_out_of_order_calls
-        @mock.should.receive(:one).ordered
-        @mock.should.receive(:two).ordered
-        @mock.should.receive(:three).ordered
-        @mock.one
-        assert_raise(MockExpectationError) do
-          @mock.three
-        end
-      end
-      
-      def test_two_ordered_calls_with_others_between
-        @mock.should.receive(:zero)
-        @mock.should.receive(:one).ordered
-        @mock.should.receive(:two).ordered
-        @mock.should.receive(:one_and_a_half)
-        @mock.one
-        @mock.one_and_a_half
-        @mock.zero
-        @mock.two
-        @mock.__verify
-      end
       
     end
   end

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

@@ -2,7 +2,6 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 
 module Spec
   module Api
-
     class MockTest < Test::Unit::TestCase
 
       def setup
@@ -10,43 +9,50 @@ module Spec
       end
 
       def test_should_report_line_number_of_expectation_of_unreceived_message
-        @mock.should.receive(:wont_happen).with("x", 3)
+        @mock.should_receive(:wont_happen).with("x", 3)
+        #NOTE - this test is quite ticklish because it specifies that
+        #the above statement appears on line 12 of this file.
 
         begin
           @mock.__verify
         rescue MockExpectationError => e
-          e.backtrace[0].should.match /mock_test\.rb:13:in .test_should_report_line/
+          e.backtrace[0].should_match /mock_test\.rb:12:in .test_should_report_line/
         end
     
       end
+      
+      def test_should_pass_when_not_receiving_message_specified_as_not_to_be_received
+        @mock.should_not_receive(:not_expected)
+        @mock.__verify
+      end
+
+      def test_should_fail_when_receiving_message_specified_as_not_to_be_received
+        @mock.should_not_receive(:not_expected)
+        assert_raise(MockExpectationError) do
+          @mock.not_expected
+        end
+      end
 
       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 }
+        @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")
         @mock.__verify
       end
 
       def test_should_allow_parameter_as_return_value
-        @mock.should.receive(:random_call).with("a","b","c").and.return("booh")
+        @mock.should_receive(:random_call).with("a","b","c").and_return("booh")
         assert_equal "booh", @mock.random_call("a","b","c")
         @mock.__verify
       end
 
       def test_return_nil_if_no_return_value_set
-        @mock.should.receive(:random_call).with("a","b","c")
+        @mock.should_receive(:random_call).with("a","b","c")
         assert_nil @mock.random_call("a","b","c")
         @mock.__verify
       end
 
-      def test_should_test_multiple_calls_to_method_with_same_parameters
-        @mock.should.receive(:random_call).twice.with("a","b","c")
-        @mock.random_call("a","b","c")
-        @mock.random_call("a","b","c")
-        @mock.__verify
-      end
-
       def test_should_raise_exception_if_parameters_dont_match_when_method_called
-        @mock.should.receive(:random_call).with("a","b","c").and.return("booh")
+        @mock.should_receive(:random_call).with("a","b","c").and_return("booh")
         assert_raise(MockExpectationError) {
           @mock.random_call("a","d","c")
         }
@@ -58,223 +64,48 @@ module Spec
         }
       end
   
-      # TODO: rename to should_raise_exception_telling_what_message_was_not_received
-      def test_should_raise_exception_on_verify_if_call_counts_not_as_expected
-        @mock.should.receive(:random_call).twice.with("a","b","c").and.return("booh")
-        @mock.random_call("a","b","c")
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-
       def test_should_use_block_for_expectation_if_provided
-        @mock.should.receive(:random_call) do | a, b |
-          a.should.equal("a")
-          b.should.equal("b")
+        @mock.should_receive(:random_call) do | a, b |
+          a.should_equal "a"
+          b.should_equal "b"
           "booh"
         end
         assert_equal("booh", @mock.random_call("a", "b"))
         @mock.__verify
       end
   
-      def test_failing_expectation_block_throws
-        @mock.should.receive(:random_call) {| a | a.should.be true}
+      def test_should_fail_if_expectation_block_fails
+        @mock.should_receive(:random_call) {| a | a.should_be true}
         assert_raise(MockExpectationError) do
           @mock.random_call false
         end
       end
   
-      def test_two_return_values
-        @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([11, 22])
-        assert_equal(11, @mock.multi_call)
-        assert_equal(22, @mock.multi_call)
-        assert_equal(22, @mock.multi_call)
-        @mock.__verify
-      end
-  
-      def test_should_throw_on_call_of_never_method
-        @mock.should.receive(:random_call).never
+      def test_should_fail_when_method_defined_as_never_is_received
+        @mock.should_receive(:random_call).never
+        #TODO - @mock.should_not_receive(:random_call)
         assert_raise(MockExpectationError) do
           @mock.random_call
           @mock.__verify
         end
       end
-  
-      def test_should_throw_if_at_least_once_method_not_called
-        @mock.should.receive(:random_call).at.least(:once)
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-  
-      def test_should_not_throw_if_any_number_of_times_method_not_called
-        @mock.should.receive(:random_call).any.number.of.times
-        @mock.__verify
-      end
-  
-      def test_should_not_throw_if_any_number_of_times_method_is_called
-        @mock.should.receive(:random_call).any.number.of.times
-        @mock.random_call
-        @mock.__verify
-      end
-  
-      def test_should_not_throw_if_at_least_once_method_is_called_twice
-        @mock.should.receive(:random_call).at.least(:once)
-        @mock.random_call
-        @mock.random_call
-        @mock.__verify
-      end
-  
-      def test_should_support_mutiple_calls_with_different_args
-        @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
-      end
-  
-      def test_should_support_multiple_calls_with_different_args_and_counts
-        @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
-
-      def test_should_not_throw_if_at_least_twice_method_is_called_twice
-        @mock.should.receive(:random_call).at.least(:twice)
-        @mock.random_call
-        @mock.random_call
-        @mock.__verify
-      end
-
-      def test_should_not_throw_if_at_least_twice_method_is_called_three_times
-        @mock.should.receive(:random_call).at.least(:twice)
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.__verify
-      end
-
-      def test_should_throw_if_at_least_twice_method_is_called_once
-        @mock.should.receive(:random_call).at.least(:twice)
-        @mock.random_call
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
       
-      def test_should_throw_if_at_least_twice_method_is_never_called
-        @mock.should.receive(:random_call).at.least(:twice)
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-      
-      def test_should_throw_if_at_least_5_times_method_is_never_called
-        @mock.should.receive(:random_call).at.least(5).times
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-      
-      def test_should_throw_if_at_least_5_times_method_is_called_once
-        @mock.should.receive(:random_call).at.least(5).times
-        @mock.random_call
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-      
-      def test_should_not_throw_if_at_least_5_times_method_is_called_5_times
-        @mock.should.receive(:random_call).at.least(5).times
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.__verify
-      end
-      
-      def test_should_not_throw_if_at_least_5_times_method_is_called_6_times
-        @mock.should.receive(:random_call).at.least(5).times
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.__verify
-      end
-      
-      def test_should_raise_if_exactly_3_times_method_is_not_called
-        @mock.should.receive(:random_call).exactly(3).times
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-      
-      def test_should_raise_if_exactly_3_times_method_is_called_once
-        @mock.should.receive(:random_call).exactly(3).times
-        @mock.random_call
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-      
-      def test_should_raise_if_exactly_3_times_method_is_called_twice
-        @mock.should.receive(:random_call).exactly(3).times
-        @mock.random_call
-        @mock.random_call
-        assert_raise(MockExpectationError) do
-          @mock.__verify
-        end
-      end
-      
-      def test_should_not_raise_if_exactly_3_times_method_is_called_3_times
-        @mock.should.receive(:random_call).exactly(3).times
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        assert_nothing_raised do
-          @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
-        @mock.random_call
-        @mock.random_call
-        assert_nothing_raised do
-          @mock.random_call
-        end
-      end
-
       def test_should_raise_when_told_to
-        @mock.should.receive(:random_call).and.raise(RuntimeError)
+        @mock.should_receive(:random_call).and_raise(RuntimeError)
         assert_raise(RuntimeError) do
           @mock.random_call
         end
       end
  
       def test_should_not_raise_when_told_to_if_args_dont_match
-        @mock.should.receive(:random_call).with(2).and.raise(RuntimeError)
+        @mock.should_receive(:random_call).with(2).and_raise(RuntimeError)
         assert_raise(MockExpectationError) do
-          @mock.random_call(1)
+          @mock.random_call 1
         end
       end
  
       def test_should_throw_when_told_to
-        @mock.should.receive(:random_call).and.throw(:blech)
+        @mock.should_receive(:random_call).and_throw(:blech)
         assert_throws(:blech) do
           @mock.random_call
         end
@@ -282,76 +113,76 @@ module Spec
 
       def test_should_raise_when_explicit_return_and_block_constrained
         assert_raise(AmbiguousReturnError) {
-          @mock.should.receive(:fruit){|colour|
+          @mock.should_receive(:fruit){|colour|
             :strawberry
-          }.and.return :apple
+          }.and_return :apple
         }
       end
       
       def TODO_test_should_use_past_tense
-        @mock.should.have.received(:hello)
+        @mock.should_have_received(:hello)
       end
 
       def TODO_test_should_sent
-        cut.should.have.sent(:hello)
-        cut.should.have.sent(:hello).to(@mock)
+        cut.should_have_sent(:hello)
+        cut.should_have_sent(:hello).to(@mock)
       end
      
       def test_should_ignore_args_on_any_args
-        @mock.should.receive(:random_call).at.least(:once).with(:any_args)
-        @mock.random_call()
-        @mock.random_call(1)
-        @mock.random_call("a", 2)
-        @mock.random_call([], {}, "joe", 7)
+        @mock.should_receive(:random_call).at_least(:once).with(:any_args)
+        @mock.random_call
+        @mock.random_call 1
+        @mock.random_call "a", 2
+        @mock.random_call [], {}, "joe", 7
         @mock.__verify
       end
       
-      def test_should_throw_on_no_args_if_any_args_received
-        @mock.should.receive(:random_call).with(:no_args)
+      def test_should_fail_on_no_args_if_any_args_received
+        @mock.should_receive(:random_call).with(:no_args)
         assert_raise(MockExpectationError) do
-          @mock.random_call(1)
+          @mock.random_call 1
         end
       end
       
-      def test_should_yield_values
-        @mock.should.receive(:yield_back).with(:no_args).once.and.yield('wha', 'zup')
-        a, b = nil
-        @mock.yield_back {|a,b|}
-        a.should.equal 'wha'
-        b.should.equal 'zup'
+      def test_should_yield_single_value
+        @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_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
+      def test_should_yield_two_values
+        @mock.should_receive(:yield_back).with(:no_args).once.and_yield('wha', 'zup')
+        a, b = nil
+        @mock.yield_back {|a,b|}
+        a.should_equal 'wha'
+        b.should_equal 'zup'
         @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')
+        @mock.should_receive(:yield_back).with(:no_args).once.and_yield('wha', 'zup')
         assert_raise(MockExpectationError) do
           @mock.yield_back {|a|}
         end
       end
 
       def test_should_fail_when_calling_yielding_method_without_block
-        @mock.should.receive(:yield_back).with(:no_args).once.and.yield('wha', 'zup')
+        @mock.should_receive(:yield_back).with(:no_args).once.and_yield('wha', 'zup')
         assert_raise(MockExpectationError) do
           @mock.yield_back
         end
       end
       
-      def test_should_be_able_to_mock_object_methods_such_as_send
-        @mock.should.receive(:send).with(:any_args)
+      def test_should_be_able_to_mock_send
+        @mock.should_receive(:send).with(:any_args)
         @mock.send 'hi'
         @mock.__verify
       end
       
       def test_should_be_able_to_raise_from_method_calling_yielding_mock
-        @mock.should.receive(:yield_me).and_yield 44
+        @mock.should_receive(:yield_me).and_yield 44
         
         lambda do
           @mock.yield_me do |x|
@@ -362,6 +193,13 @@ module Spec
         @mock.__verify
       end
 
+      def test_should_use_a_list_of_return_values_for_successive_calls
+        @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
+  
     end
   end
 end