rspec 0.6.4 → 0.7.0

data/test/spec/expectations/containment_test.rb

@@ -1,129 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    module Helper
-      class ContainmentTest < Test::Unit::TestCase
-
-        def setup
-          @dummy = 'dummy'
-          @equal_dummy = 'dummy'
-          @another_dummy  = 'another_dummy'
-          @nil_var = nil
-        end
-
-        # should_include
-  
-        def test_should_include_shouldnt_raise_when_string_inclusion_is_present
-          assert_nothing_raised do
-            @dummy.should_include "mm"
-          end
-        end
-  
-        def test_should_include_should_raise_when_string_inclusion_is_missing
-          assert_raise(ExpectationNotMetError) do
-            @dummy.should_include "abc" 
-          end
-        end
-
-        def test_should_include_shouldnt_raise_when_array_inclusion_is_present
-          assert_nothing_raised do
-            [1, 2, 3].should_include 2
-          end
-        end
-
-        def test_should_include_should_raise_when_array_inclusion_is_missing
-          assert_raise(ExpectationNotMetError) do
-            [1, 2, 3].should_include 5
-          end
-        end
-
-        def test_should_include_shouldnt_raise_when_hash_inclusion_is_present
-          assert_nothing_raised do
-            {"a"=>1}.should_include "a"
-          end
-        end
-
-        def FIXME_test_should_has_key_shouldnt_raise_when_hash_inclusion_is_present
-          assert_nothing_raised do
-            {"a"=>1}.should_has_key "a"
-          end
-        end
-
-        def FIXME_test_should_have_key_shouldnt_raise_when_hash_inclusion_is_present
-          assert_nothing_raised do
-            {"a"=>1}.should_have_key "a"
-          end
-        end
-
-        def test_should_include_should_raise_when_hash_inclusion_is_missing
-          assert_raise(ExpectationNotMetError) do
-            {"a"=>1}.should_include "b"
-          end
-        end
-
-        def test_should_include_shouldnt_raise_when_enumerable_inclusion_is_present
-          assert_nothing_raised do
-            IO.constants.should_include "SEEK_SET"
-          end
-        end
-
-        def test_should_include_should_raise_when_enumerable_inclusion_is_missing
-          assert_raise(ExpectationNotMetError) do
-            IO.constants.should_include "BLAH"
-          end
-        end
-  
-        # should_not_include
-  
-        def test_should_not_include_shouldnt_raise_when_string_inclusion_is_missing
-          assert_nothing_raised do
-            @dummy.should_not_include "abc"
-          end
-        end
-
-        def test_should_not_include_should_raise_when_string_inclusion_is_present
-          assert_raise(ExpectationNotMetError) do
-            @dummy.should_not_include "mm"
-          end
-        end
-
-        def test_should_not_include_shouldnt_raise_when_array_inclusion_is_missing
-          assert_nothing_raised do
-            [1, 2, 3].should_not_include 5
-          end
-        end
-
-        def test_should_not_include_should_raise_when_array_inclusion_is_present
-          assert_raise(ExpectationNotMetError) do
-            [1, 2, 3].should_not_include 2
-          end
-        end
-
-        def test_should_not_include_shouldnt_raise_when_hash_inclusion_is_missing
-          assert_nothing_raised do
-            {"a"=>1}.should_not_include "b"
-          end
-        end
-
-        def test_should_not_include_should_raise_when_hash_inclusion_is_present
-          assert_raise(ExpectationNotMetError) do
-            {"a"=>1}.should_not_include "a"
-          end
-        end
-
-        def test_should_not_include_shouldnt_raise_when_enumerable_inclusion_is_present
-          assert_nothing_raised do
-            IO.constants.should_not_include "BLAH"
-          end
-        end
-
-        def test_should_not_include_should_raise_when_enumerable_inclusion_is_missing
-          assert_raise(ExpectationNotMetError) do
-            IO.constants.should_not_include "SEEK_SET" 
-          end
-        end
-      end
-    end
-  end
-end

data/test/spec/expectations/diff_test.rb

@@ -1,62 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    class DiffTest < Test::Unit::TestCase
-      def test_should_output_unified_diff_of_two_strings
-        expected = <<-EOF
-foo
-bar
-zap
-this
-is
-soo
-very
-very
-equal
-insert
-a
-line
-EOF
-
-      actual = <<-EOF
-foo
-zap
-bar
-this
-is
-soo
-very
-very
-equal
-insert
-a
-another
-line
-EOF
-
-      expected_diff = <<-EOF
-
-
-@@ -1,6 +1,6 @@
- foo
--bar
- zap
-+bar
- this
- is
- soo
-@@ -9,5 +9,6 @@
- equal
- insert
- a
-+another
- line
-EOF
-
-        diff = ShouldBase.new.diff_as_string(expected, actual)
-        assert_equal expected_diff, diff
-      end
-    end
-  end
-end

data/test/spec/expectations/identity_test.rb

@@ -1,75 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    module Helper
-      class ShouldBeTest < Test::Unit::TestCase
-
-        def setup
-          @dummy = 'dummy'
-          @equal_dummy = 'dummy'
-          @another_dummy  = 'another_dummy'
-          @nil_var = nil
-        end
-
-        def test_should_not_raise_when_objects_are_same
-          assert_nothing_raised do
-            @dummy.should_be @dummy
-          end
-        end
-
-        def test_should_raise_when_objects_are_not_same
-          assert_raise(ExpectationNotMetError) do
-            @dummy.should_be @equal_dummy
-          end
-        end
-
-        def test_should_not_raise_when_both_objects_are_nil
-          assert_nothing_raised do
-            @nil_var.should_be nil
-          end  
-        end
-
-        def test_should_raise_when_object_is_not_nil
-          assert_raise(ExpectationNotMetError) do
-            @dummy.should_be nil
-          end
-        end
-      end
-
-      class ShouldNotBeTest < Test::Unit::TestCase
-        def setup
-          @dummy = 'dummy'
-          @equal_dummy = 'dummy'
-          @another_dummy  = 'another_dummy'
-          @nil_var = nil
-        end
-
-        def test_should_not_raise_when_objects_are_not_same
-          assert_nothing_raised do
-            @dummy.should_not_be @equal_dummy
-          end
-        end
-
-        def test_should_raise_when_objects_are_same
-          assert_raise(ExpectationNotMetError) do
-            @dummy.should_not_be @dummy
-          end
-        end
-
-        def test_should_not_raise_when_left_is_not_nil_and_right_is_nil
-          assert_nothing_raised do
-            @dummy.should_not_be nil
-          end  
-        end
-
-        def test_should_raise_when_both_objects_are_nil
-          assert_raise(ExpectationNotMetError) do
-            @nil_var.should_not_be nil
-          end
-        end
-
-      end
-    end
-  end
-end

data/test/spec/expectations/object_equality_test.rb

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    module Helper
-      class ShouldEqualTest < Test::Unit::TestCase
-
-        def test_should_not_raise_when_objects_are_equal
-          assert_nothing_raised do
-            'apple'.should_equal 'apple'
-          end
-        end
-  
-        def test_should_raise_when_objects_are_not_equal
-          assert_raise(ExpectationNotMetError) do
-            'apple'.should_equal 'orange'
-          end
-        end        
-      end
-
-      class ShouldNotEqualTest < Test::Unit::TestCase
-
-        def test_should_not_raise_when_objects_are_not_equal
-          assert_nothing_raised do
-            'apple'.should_not_equal 'orange'
-          end
-        end
-
-        def test_should_not_equal_should_raise_when_objects_are_equal
-          assert_raise(ExpectationNotMetError) do
-            'apple'.should_not_equal 'apple'
-          end
-        end
-      end
-
-      class ShouldBeCloseTest < Test::Unit::TestCase
-        def test_should_not_raise_when_values_are_within_bounds
-          assert_nothing_raised do
-            3.5.should_be_close 3.5, 0.5
-            3.5.should_be_close 3.1, 0.5
-            3.5.should_be_close 3.01, 0.5
-            3.5.should_be_close 3.9, 0.5
-            3.5.should_be_close 3.99, 0.5
-          end
-        end
-        
-        def test_should_raise_when_values_are_outside_bounds
-          assert_raise(ExpectationNotMetError) do
-            3.5.should_be_close 3.0, 0.5
-          end
-          assert_raise(ExpectationNotMetError) do
-            3.5.should_be_close 2.0, 0.5
-          end
-          assert_raise(ExpectationNotMetError) do
-            3.5.should_be_close 4.0, 0.5
-          end
-          assert_raise(ExpectationNotMetError) do
-            3.5.should_be_close 5.0, 0.5
-          end
-        end
-
-      end
-    end
-  end
-end

data/test/spec/expectations/raising_test.rb

@@ -1,106 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    module Helper
-      class ShouldRaiseTest < Test::Unit::TestCase
-
-        def test_should_pass_when_exact_exception_is_raised
-          assert_nothing_raised do
-            proc { ''.nonexistent_method }.should_raise NoMethodError
-          end
-        end
-  
-        def test_should_pass_when_exact_exception_is_raised_with_message
-          assert_nothing_raised do
-            lambda { raise StandardError.new("this is standard") }.should_raise StandardError, "this is standard"
-          end
-        end
-  
-        def test_should_fail_when_exact_exception_is_raised_with_wrong_message
-          assert_raises(Spec::Expectations::ExpectationNotMetError) do
-            lambda { raise StandardError.new("chunky bacon") }.should_raise StandardError, "rotten tomatoes"
-          end
-        end
-  
-        def test_should_pass_when_subclass_exception_is_raised
-          assert_nothing_raised do
-            proc { ''.nonexistent_method }.should_raise
-          end
-        end
-  
-        def test_should_fail_when_wrong_exception_is_raised
-          begin
-            proc { ''.nonexistent_method }.should_raise SyntaxError
-          rescue => e
-          end
-          assert_equal("<Proc> should raise <SyntaxError> but raised #<NoMethodError: undefined method `nonexistent_method' for \"\":String>", e.message)
-        end
-  
-        def test_should_fail_when_no_exception_is_raised
-          begin
-            proc { }.should_raise SyntaxError
-          rescue => e
-          end
-          assert_equal("<Proc> should raise <SyntaxError> but raised nothing", e.message)
-        end
-      end
-        
-      class ShouldNotRaiseTest < Test::Unit::TestCase
-  
-        def test_should_pass_when_exact_exception_is_raised_with_wrong_message
-          assert_nothing_raised do
-            lambda { raise StandardError.new("abc") }.should_not_raise StandardError, "xyz"
-          end
-        end
-  
-        def test_should_faile_when_exact_exception_is_raised_with_message
-          assert_raises(Spec::Expectations::ExpectationNotMetError) do
-            lambda { raise StandardError.new("abc") }.should_not_raise StandardError, "abc"
-          end
-        end
-  
-        def test_should_pass_when_other_exception_is_raised
-          assert_nothing_raised do
-            proc { ''.nonexistent_method }.should_not_raise SyntaxError
-          end
-        end
-  
-        def test_should_pass_when_no_exception_is_raised
-          assert_nothing_raised do
-            proc { ''.to_s }.should_not_raise NoMethodError
-          end
-        end
-
-        def test_without_exception_should_pass_when_no_exception_is_raised
-          assert_nothing_raised do
-            proc { ''.to_s }.should_not_raise
-          end
-        end
-        
-        def test_should_fail_when_specific_exception_is_raised
-          begin
-            proc { ''.nonexistent_method }.should_not_raise NoMethodError
-          rescue => e
-          end
-          assert_equal("<Proc> should not raise <NoMethodError>", e.message)
-        end
-  
-        def test_should_include_actual_error_in_failure_message
-          begin
-            proc { ''.nonexistent_method }.should_not_raise Exception
-          rescue => e
-          end
-          assert_equal("<Proc> should not raise <Exception> but raised #<NoMethodError: undefined method `nonexistent_method' for \"\":String>", e.message)
-        end
-  
-        def TODOtest_should_understand_raised_with_message_matching
-          lambda do
-            raise 'Hello'
-          end.should_raise(StandardError).with.message.matching(/ello/)
-        end
-
-      end
-    end
-  end
-end

data/test/spec/expectations/regex_matching_test.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    module Helper
-      class ShouldMatchTest < Test::Unit::TestCase
-
-        def test_should_not_raise_when_objects_match
-          assert_nothing_raised do
-            "hi aslak".should_match(/aslak/)
-          end
-        end
-
-        def test_should_raise_when_objects_do_not_match
-          assert_raise(ExpectationNotMetError) do
-            "hi aslak".should_match(/steve/)
-          end
-        end
-      end
-
-      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_raise_when_objects_match
-          assert_raise(ExpectationNotMetError) do
-            "hi aslak".should_not_match(/aslak/)
-          end
-        end
-      end
-    end
-  end
-end