rspec 0.5.16 → 0.6.0

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

@@ -2,76 +2,82 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 
 module Spec
   module Api
-    class PassingConstraintsToMockTest < Test::Unit::TestCase
+    class PassingMockArgumentConstraintsTest < Test::Unit::TestCase
       
       def setup
         @mock = Mock.new("test mock")
       end
 
-      def test_should_handle_any_arg
-        @mock.should.receive(:random_call).with("a", :anything, "c")
+      def test_should_accept_string_as_anything
+        @mock.should_receive(:random_call).with("a", :anything, "c")
         @mock.random_call("a", "whatever", "c")
         @mock.__verify
       end
       
       def test_should_accept_fixnum_as_numeric
-        @mock.should.receive(:random_call).with(:numeric)
+        @mock.should_receive(:random_call).with(:numeric)
         @mock.random_call(1)
         @mock.__verify
       end
       
       def test_should_accept_float_as_numeric
-        @mock.should.receive(:random_call).with(:numeric)
+        @mock.should_receive(:random_call).with(:numeric)
         @mock.random_call(1.5)
         @mock.__verify
       end
       
-      def test_should_match_true_for_boolean
-        @mock.should.receive(:random_call).with(:boolean)
+      def test_should_accept_true_as_boolean
+        @mock.should_receive(:random_call).with(:boolean)
         @mock.random_call(true)
         @mock.__verify
       end
       
-      def test_should_match_false_for_boolean
-        @mock.should.receive(:random_call).with(:boolean)
+      def test_should_accept_false_as_boolean
+        @mock.should_receive(:random_call).with(:boolean)
         @mock.random_call(false)
         @mock.__verify
       end
       
       def test_should_match_string
-        @mock.should.receive(:random_call).with(:string)
+        @mock.should_receive(:random_call).with(:string)
         @mock.random_call("a string")
         @mock.__verify
       end
       
       def test_should_match_non_special_symbol
-        @mock.should.receive(:random_call).with(:some_symbol)
+        @mock.should_receive(:random_call).with(:some_symbol)
         @mock.random_call(:some_symbol)
         @mock.__verify
       end
       
-      def test_should_process_duck_type_with_one_method
-        @mock.should.receive(:random_call).with(DuckTypeArgConstraint.new(:length))
+      def test_should_match_duck_type_with_one_method
+        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:length))
         @mock.random_call([])
         @mock.__verify
       end
       
-      def test_should_process_duck_type_with_two_methods
-        @mock.should.receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
+      def test_should_match_duck_type_with_two_methods
+        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
         @mock.random_call(1)
         @mock.__verify
       end
       
+      def test_should_match_user_defined_type
+        @mock.should_receive(:random_call).with(Person.new("David"))
+        @mock.random_call(Person.new("David"))
+        @mock.__verify
+      end
+      
     end
     
-    class FailingConstraintsTest < Test::Unit::TestCase
+    class FailingMockArgumentConstraintsTest < Test::Unit::TestCase
       
       def setup
         @mock = Mock.new("test mock")
       end
 
       def test_should_reject_non_numeric
-        @mock.should.receive(:random_call).with(:numeric)
+        @mock.should_receive(:random_call).with(:numeric)
         assert_raise(MockExpectationError) do
           @mock.random_call("1")
           @mock.__verify
@@ -79,7 +85,7 @@ module Spec
       end
       
       def test_should_reject_non_boolean
-        @mock.should.receive(:random_call).with(:boolean)
+        @mock.should_receive(:random_call).with(:boolean)
         assert_raise(MockExpectationError) do
           @mock.random_call("false")
           @mock.__verify
@@ -87,7 +93,7 @@ module Spec
       end
       
       def test_should_reject_non_string
-        @mock.should.receive(:random_call).with(:string)
+        @mock.should_receive(:random_call).with(:string)
         assert_raise(MockExpectationError) do
           @mock.random_call(123)
           @mock.__verify
@@ -95,7 +101,7 @@ module Spec
       end
       
       def test_should_reject_goose_when_expecting_a_duck
-        @mock.should.receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
+        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
         assert_raise(MockExpectationError) do
           @mock.random_call("I don't respond to :abs or :div")
           @mock.__verify

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

@@ -0,0 +1,431 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Spec
+  module Api
+    class OnceCountsTest < Test::Unit::TestCase
+      
+      def setup
+        @mock = Mock.new("test mock")
+      end
+      
+      def test_once_should_pass_when_called_once
+        @mock.should_receive(:random_call).once
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_once_should_pass_when_called_once_with_unspecified_args
+        @mock.should_receive(:random_call).once
+        @mock.random_call("a","b","c")
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_once_should_pass_when_called_once_with_specified_args
+        @mock.should_receive(:random_call).once.with("a","b","c")
+        @mock.random_call("a","b","c")
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+      
+      def test_once_should_fail_when_not_called
+        @mock.should_receive(:random_call).once
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+
+      def test_once_should_fail_when_called_twice
+        @mock.should_receive(:random_call).once
+        @mock.random_call
+        @mock.random_call
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+
+      def test_once_should_fail_when_called_once_with_wrong_args
+        @mock.should_receive(:random_call).once.with("a","b","c")
+        assert_raise(MockExpectationError) do
+          @mock.random_call "d","e","f"
+        end
+      end
+    end
+    
+    class TwiceCountsTest < Test::Unit::TestCase
+
+      def setup
+        @mock = Mock.new("test mock")
+      end
+      
+      def test_twice_should_pass_when_called_twice
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_twice_should_pass_when_called_twice_with_unspecified_args
+        @mock.should_receive(:random_call).twice
+        @mock.random_call "1"
+        @mock.random_call 1
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_twice_should_pass_when_called_twice_with_specified_args
+        @mock.should_receive(:random_call).twice.with("1", 1)
+        @mock.random_call "1", 1
+        @mock.random_call "1", 1
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_twice_should_fail_when_called_twice_with_wrong_args_on_the_second_call
+        @mock.should_receive(:random_call).twice.with("1", 1)
+        @mock.random_call "1", 1
+        assert_raise(MockExpectationError) do
+          @mock.random_call 1, "1"
+        end
+      end
+
+      def test_twice_should_fail_when_called_twice_with_wrong_args_on_the_first_call
+        @mock.should_receive(:random_call).twice.with("1", 1)
+        assert_raise(MockExpectationError) do
+          @mock.random_call 1, "1"
+        end
+      end
+
+      def test_twice_should_fail_when_call_count_is_lower_than_expected
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+
+      def test_twice_should_fail_when_call_count_is_higher_than_expected
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+    end
+
+    class AnyNumberOfTimesTest < Test::Unit::TestCase
+      
+      def setup
+        @mock = Mock.new("test mock")
+      end
+
+      def test_should_pass_if_any_number_of_times_method_is_not_called
+        @mock.should_receive(:random_call).any_number_of_times
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+  
+      def test_should_pass_if_any_number_of_times_method_is_called_once
+        @mock.should_receive(:random_call).any_number_of_times
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+  
+      def test_should_pass_if_any_number_of_times_method_is_called_many_times
+        @mock.should_receive(:random_call).any_number_of_times
+        (1..10).each { @mock.random_call }
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+    end
+
+    class PreciseCountsTest < Test::Unit::TestCase
+      
+      def setup
+        @mock = Mock.new("test mock")
+      end
+
+      def test_should_pass_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)
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+  
+      def test_should_pass_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)
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_fail_when_exactly_n_times_method_is_never_called
+        @mock.should_receive(:random_call).exactly(3).times
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+      
+      def test_should_fail_when_exactly_n_times_method_is_called_less_than_n_times
+        @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_pass_if_exactly_n_times_method_is_called_exactly_n_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
+      
+    end
+    
+    class AtLeastTest < Test::Unit::TestCase
+      
+      def setup
+        @mock = Mock.new("test mock")
+      end
+
+      def test_should_fail_when_at_least_once_method_is_never_called
+        @mock.should_receive(:random_call).at_least(:once)
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+  
+      def test_should_pass_when_at_least_once_method_is_called_once
+        @mock.should_receive(:random_call).at_least(:once)
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+  
+      def test_should_pass_when_at_least_once_method_is_called_twice
+        @mock.should_receive(:random_call).at_least(:once)
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_fail_when_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_fail_when_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_pass_when_at_least_twice_method_is_called_twice
+        @mock.should_receive(:random_call).at_least(:twice)
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_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
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+      
+      def test_should_fail_at_least_n_times_method_is_never_called
+        @mock.should_receive(:random_call).at_least(4).times
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+      
+      def test_should_fail_when_at_least_n_times_method_is_called_less_than_n_times
+        @mock.should_receive(:random_call).at_least(4).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+      
+      def test_should_pass_when_at_least_n_times_method_is_called_exactly_n_times
+        @mock.should_receive(:random_call).at_least(4).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+      
+      def test_should_pass_when_at_least_n_times_method_is_called_n_plus_1_times
+        @mock.should_receive(:random_call).at_least(4).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+  
+      def test_should_use_last_return_value_for_subsequent_calls
+        @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)
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+    end
+
+    class AtMostTest < Test::Unit::TestCase
+
+      def setup
+        @mock = Mock.new("test mock")
+      end
+
+      def test_should_pass_when_at_most_once_method_is_never_called
+        @mock.should_receive(:random_call).at_most(:once)
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_at_most_once_method_is_called_once
+        @mock.should_receive(:random_call).at_most(:once)
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_fail_when_at_most_once_method_is_called_twice
+        @mock.should_receive(:random_call).at_most(:once)
+        @mock.random_call
+        @mock.random_call
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_at_most_twice_method_is_never_called
+        @mock.should_receive(:random_call).at_most(:twice)
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_at_most_twice_method_is_called_once
+        @mock.should_receive(:random_call).at_most(:twice)
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_at_most_twice_method_is_called_twice
+        @mock.should_receive(:random_call).at_most(:twice)
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_fail_when_at_most_twice_method_is_called_three_times
+        @mock.should_receive(:random_call).at_most(:twice)
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_at_most_n_times_method_is_never_called
+        @mock.should_receive(:random_call).at_most(4).times
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_at_most_n_times_method_is_called_less_than_n_times
+        @mock.should_receive(:random_call).at_most(4).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_pass_when_at_most_n_times_method_is_called_exactly_n_times
+        @mock.should_receive(:random_call).at_most(4).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_nothing_raised do
+          @mock.__verify
+        end
+      end
+
+      def test_should_fail_when_at_most_n_times_method_is_called_n_plus_1_times
+        @mock.should_receive(:random_call).at_most(4).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        assert_raise(MockExpectationError) do
+          @mock.__verify
+        end
+      end
+    end
+  end
+end