rspec 0.5.0 → 0.5.1

data/test/spec/api/mock_arg_constraints_test.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Spec
+  module Api
+    class PassingConstraintsTest < Test::Unit::TestCase
+      
+      def setup
+        @mock = Mock.new("test mock")
+      end
+
+      def test_should_handle_anything
+        @mock.should.receive(:random_call).at.least(:once).with(:anything)
+        @mock.random_call()
+        @mock.random_call(1)
+        @mock.random_call("a", 2)
+        @mock.random_call([], {}, "joe", 7)
+        @mock.__verify
+      end
+      
+      def test_should_handle_anything_in_multi_args
+        @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.random_call(1)
+        @mock.__verify
+      end
+      
+      def test_should_accept_float_as_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)
+        @mock.random_call(true)
+        @mock.__verify
+      end
+      
+      def test_should_match_false_for_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.random_call("a string")
+        @mock.__verify
+      end
+      
+    end
+    
+    class FailingConstraintsTest < Test::Unit::TestCase
+      
+      def setup
+        @mock = Mock.new("test mock")
+      end
+
+      def test_should_reject_non_numeric
+        @mock.should.receive(:random_call).with(:numeric)
+        assert_raise(MockExpectationError) do
+          @mock.random_call("1")
+          @mock.__verify
+        end
+      end
+      
+      def test_should_reject_non_boolean
+        @mock.should.receive(:random_call).with(:boolean)
+        assert_raise(MockExpectationError) do
+          @mock.random_call("false")
+          @mock.__verify
+        end
+      end
+      
+      def test_should_reject_non_string
+        @mock.should.receive(:random_call).with(:string)
+        assert_raise(MockExpectationError) do
+          @mock.random_call(123)
+          @mock.__verify
+        end
+      end
+      
+    end
+  end
+end

data/test/spec/api/mock_test.rb

@@ -10,7 +10,7 @@ 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)
 
         begin
           @mock.__verify
@@ -21,33 +21,33 @@ module Spec
       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")
         # TODO: remove __verify when migrating to self-hosting. Verify happens transparently in teardown. (AH)
         @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.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")
         }
@@ -67,7 +67,7 @@ module Spec
   
       # 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.should.receive(:random_call).twice.with("a","b","c").and.return("booh")
         @mock.random_call("a","b","c")
         assert_raise(MockExpectationError) do
           @mock.__verify
@@ -75,7 +75,7 @@ module Spec
       end
 
       def test_should_use_block_for_expectation_if_provided
-        @mock.should_receive(:random_call) do | a, b |
+        @mock.should.receive(:random_call) do | a, b |
           a.should.equal("a")
           b.should.equal("b")
           "booh"
@@ -85,21 +85,21 @@ module Spec
       end
   
       def test_failing_expectation_block_throws
-        @mock.should_receive(:random_call) {| a | a.should.be true}
+        @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_consecutively([1, 2])
+        @mock.should.receive(:multi_call).twice.with(:nothing).and.return([1, 2])
         assert_equal(1, @mock.multi_call)
         assert_equal(2, @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_consecutively([1, 2])
+        @mock.should.receive(:multi_call).at.least(:once).with(:nothing).and.return([1, 2])
         assert_equal(1, @mock.multi_call)
         assert_equal(2, @mock.multi_call)
         assert_equal(2, @mock.multi_call)
@@ -107,7 +107,7 @@ module Spec
       end
   
       def test_should_throw_on_call_of_never_method
-        @mock.should_receive(:random_call).never
+        @mock.should.receive(:random_call).never
         assert_raise(MockExpectationError) do
           @mock.random_call
           @mock.__verify
@@ -115,47 +115,127 @@ module Spec
       end
   
       def test_should_throw_if_at_least_once_method_not_called
-        @mock.should_receive(:random_call).at_least_once
+        @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.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.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.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.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.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_raising
+        @mock.should.receive(:random_call).and.raise(RuntimeError)
+        assert_raise(RuntimeError) do
+          @mock.random_call
+        end
+      end
+ 
+      def test_throwing
+        @mock.should.receive(:random_call).and.throw(:blech)
+        assert_throws(:blech) do
+          @mock.random_call
+        end
+      end
+     
     end
   end
 end

data/test/spec/runner/context_runner_test.rb

@@ -5,9 +5,9 @@ module Spec
       def test_should_call_run_doc_on_context
         context1 = Api::Mock.new "context1"
         context2 = Api::Mock.new "context2"
-        context1.should_receive(:run_docs)
-        context2.should_receive(:run_docs)
-        runner = ContextRunner.new ["-d"]
+        context1.should.receive(:run_docs)
+        context2.should.receive(:run_docs)
+        runner = ContextRunner.new ["-d"], false, StringIO.new
         runner.add_context context1
         runner.add_context context2        
         runner.run

data/test/spec/runner/context_test.rb

@@ -10,19 +10,16 @@ module Spec
       end
       
       def test_should_add_itself_to_listener_on_run
-        @listener.should_receive(:add_context).with "context"
+        @listener.should.receive(:add_context).with "context", :anything
         @context.run(@listener)
         @listener.__verify
       end
       
       def test_should_add_itself_to_listener_on_run_docs
-        @listener.should_receive(:add_context).with "context"
+        @listener.should.receive(:add_context).with "context"
         @context.run_docs(@listener)
         @listener.__verify
       end
-      
-      def test_should_execute_setup_from_inherited_context
-      end
 
     end
   end

data/test/spec/runner/execution_context_test.rb

@@ -4,7 +4,7 @@ module Spec
     class ExecutionContextTest < Test::Unit::TestCase
       def test_should_add_new_mock_to_spec_when_mock_message_received
         spec = Api::Mock.new "spec"
-        spec.should_receive(:add_mock) {|mock| mock.should.be.instance.of Api::Mock}
+        spec.should.receive(:add_mock) {|mock| mock.instance_of? Api::Mock}
         ec = ExecutionContext.new spec
         mock = ec.mock("a mock")
       end

data/test/spec/runner/option_parser_test.rb

@@ -5,46 +5,54 @@ module Spec
   module Runner
     class OptionParserTest < Test::Unit::TestCase
 
+      def setup
+        @err = StringIO.new
+      end
+
       def test_verbose_should_be_true_by_default
-        options = OptionParser.parse([])
+        options = OptionParser.parse([], false, @err)
         assert(!options.verbose)
       end
 
       def test_out_should_be_stdout_by_default
-        options = OptionParser.parse([])
+        options = OptionParser.parse([], false, @err)
         assert_equal(STDOUT, options.out)
       end
       
       def test_verbose_should_be_settable_with_v
-        options = OptionParser.parse(["-v"])
+        options = OptionParser.parse(["-v"], false, @err)
         assert(options.verbose)
       end
       
       def test_verbose_should_be_settable_with_verbose
-        options = OptionParser.parse(["--verbose"])
+        options = OptionParser.parse(["--verbose"], false, @err)
         assert(options.verbose)
       end
       
       def test_doc_should_be_false_by_default
-        options = OptionParser.parse([])
+        options = OptionParser.parse([], false, @err)
         assert(!options.doc)
       end
       
       def test_doc_should_be_settable_with_d
-        options = OptionParser.parse(["-d"])
+        options = OptionParser.parse(["-d"], false, @err)
         assert(options.doc)
       end
       
       def test_out_should_be_settable_with_o
-        options = OptionParser.parse(["-o","test.txt"])
+        options = OptionParser.parse(["-o","test.txt"], false, @err)
         assert_equal("test.txt", options.out)
       end
       
       def test_out_should_be_settable_with_of
-        options = OptionParser.parse(["--of","test.txt"])
+        options = OptionParser.parse(["--of","test.txt"], false, @err)
         assert_equal("test.txt", options.out)
       end
       
+      def test_should_print_usage_if_no_dir_specified
+        options = OptionParser.parse([], false, @err)
+        assert_match(/Usage: spec/, @err.string)
+      end
     end
   end
 end

data/test/spec/runner/simple_text_reporter_test.rb

@@ -25,22 +25,23 @@ module Spec
       end
   
       def test_should_account_for_context_in_stats_for_pass
-        @reporter.add_context Context.new("context") {}
+        @reporter.add_context "context", "calling line"
         @reporter.dump
         assert_match(/1 context, 0 specifications, 0 failures/, @io.string)
       end
   
       def test_should_account_for_spec_in_stats_for_pass
-        @reporter.add_spec Specification.new("spec") {}
+        @reporter.add_spec Specification.new("spec"), "calling line", {}
         @reporter.dump
         assert_match(/0 contexts, 1 specification, 0 failures/, @io.string)
       end
   
       def test_should_account_for_spec_and_error_in_stats_for_pass
-        @backtrace_tweaker.should_receive(:tweak_backtrace)
-        @reporter.add_spec Specification.new("spec"), [RuntimeError.new]
+        @backtrace_tweaker.should.receive(:tweak_backtrace)
+        @reporter.add_context "context", "calling line"
+        @reporter.add_spec Specification.new("spec"), "calling line", [RuntimeError.new]
         @reporter.dump
-        assert_match(/0 contexts, 1 specification, 1 failure/, @io.string)
+        assert_match(/1 context, 1 specification, 1 failure/, @io.string)
       end
       
       def test_should_handle_multiple_contexts_same_name
@@ -52,23 +53,52 @@ module Spec
       end
   
       def test_should_handle_multiple_specs_same_name
-        @backtrace_tweaker.should_receive(:tweak_backtrace)
-        @reporter.add_context Context.new("context") {}
-        @reporter.add_spec Specification.new("spec") {}
-        @reporter.add_spec Specification.new("spec"), [RuntimeError.new]
-        @reporter.add_context Context.new("context") {}
-        @reporter.add_spec Specification.new("spec") {}
-        @reporter.add_spec Specification.new("spec"), [RuntimeError.new]
+        @backtrace_tweaker.should.receive(:tweak_backtrace)
+        @reporter.add_context "context", "calling line"
+        @reporter.add_spec "spec", "calling line"
+        @reporter.add_spec "spec", "calling line", [RuntimeError.new]
+        @reporter.add_context "context", "calling line"
+        @reporter.add_spec "spec", "calling line"
+        @reporter.add_spec "spec", "calling line", [RuntimeError.new]
         @reporter.dump
         assert_match(/2 contexts, 4 specifications, 2 failures/, @io.string)
       end
       
       def test_should_delegate_to_backtrace_tweaker
-        @backtrace_tweaker.should_receive(:tweak_backtrace)
-        @reporter.add_spec Specification.new("spec"), [RuntimeError.new]
+        @backtrace_tweaker.should.receive(:tweak_backtrace)
+        @reporter.add_context "context", "calling line"
+        @reporter.add_spec "spec", "calling line", [RuntimeError.new]
         @backtrace_tweaker.__verify
       end
-  
+
+    end
+    
+    class FailureDumpTest < Test::Unit::TestCase
+
+      def setup
+        @io = StringIO.new
+        @reporter = SimpleTextReporter.new(@io)
+        @reporter.add_context "failing context", "calling line for context"
+        @reporter.add_spec "failing spec", "calling line for spec", [RuntimeError.new]
+        @reporter.dump
+      end
+
+      def test_should_include_context
+        assert_match(/failing context/, @io.string)
+      end
+
+      def test_should_include_context_calling_line
+        assert_match(/\[calling line for context\]/, @io.string)
+      end
+
+      def test_should_include_spec
+        assert_match(/failing spec/, @io.string)
+      end
+      
+      def test_should_include_spec_calling_line
+        assert_match(/[calling line for spec]/, @io.string)
+      end
+      
     end
 
     class SimpleTextReporterQuietOutputTest < Test::Unit::TestCase
@@ -76,51 +106,45 @@ module Spec
       def setup
         @io = StringIO.new
         @reporter = SimpleTextReporter.new(@io)
+        @reporter.add_context "context", "calling line for context"
       end
       
       def test_should_remain_silent_when_context_name_provided
-        @reporter.add_context "context"
         assert_equal("\n", @io.string)
       end
       
       def test_should_output_dot_when_spec_passed
-        @reporter.add_spec "spec"
-        assert_equal(".", @io.string)
+        @reporter.add_spec "spec", "calling line"
+        assert_equal("\n.", @io.string)
       end
 
       def test_should_output_F_when_spec_failed
-        @reporter.add_spec "spec", [RuntimeError.new]
-        assert_equal("F", @io.string)
+        @reporter.add_spec "spec", "calling line", [RuntimeError.new]
+        assert_equal("\nF", @io.string)
       end
-
+      
     end
 
-
     class SimpleTextReporterVerboseOutputTest < Test::Unit::TestCase
 
       def setup
         @io = StringIO.new
         @reporter = SimpleTextReporter.new(@io, true)
+        @reporter.add_context "context", "calling line for context"
       end
       
       def test_should_output_when_context_name_provided
-        @reporter.add_context "context"
-        assert_equal("\ncontext\n", @io.string)
+        assert_match(/\ncontext\n/, @io.string)
       end
       
       def test_should_output_spec_name_when_spec_passed
-        @reporter.add_spec "spec"
-        assert_equal("- spec\n", @io.string)
+        @reporter.add_spec "spec", "calling line"
+        assert_match(/- spec\n/, @io.string)
       end
 
       def test_should_output_failure_when_spec_failed
-        error = RuntimeError.new
-        begin
-          raise error
-        rescue
-        end
-        @reporter.add_spec "spec", [error]
-        assert_equal("- spec (FAILED)\n#{error.message} (#{error.class.name})\n#{error.backtrace.join("\n")}\n", @io.string)
+        @reporter.add_spec "spec", "calling line", [RuntimeError.new]
+        assert_match(/spec \(FAILED - 1\)/, @io.string)
       end
 
     end