rspec 0.1.4 → 0.1.5

data/test/error_reporting_test.rb

@@ -0,0 +1,271 @@
+require 'test/unit'
+
+require 'spec'
+
+
+class ErrorReportingContext < Spec::Context
+
+  # should
+
+  def use_the_standard_message_for_should
+    Object.should { false == true }
+  end
+
+  def use_the_provided_message_for_should
+    Object.should("provided message") { false == true }
+  end
+  
+  # should_equal
+
+  def use_the_standard_message_for_should_equal
+    Object.should_equal Class
+  end
+
+  def use_the_provided_message_for_should_equal
+    Object.should_equal(Class, "provided for should_equal")
+  end
+
+  # should_not_equal
+
+  def use_the_standard_message_for_should_not_equal
+    Object.should_not_equal Object
+  end
+
+  def use_the_provided_message_for_should_not_equal
+    Object.should_not_equal(Object, "provided for should_not_equal")
+  end
+
+  # should_be_nil
+  
+  def use_the_standard_message_for_should_be_nil
+    Object.should_be_nil
+  end
+
+  def use_the_provided_message_for_should_be_nil
+    Object.should_be_nil("provided for should_be_nil")
+  end
+
+  # should_not_be_nil
+  
+  def use_the_standard_message_for_should_not_be_nil
+    nil.should_not_be_nil
+  end
+
+  def use_the_provided_message_for_should_not_be_nil
+    nil.should_not_be_nil("provided for should_not_be_nil")
+  end
+
+  # should_be_empty
+  
+  def use_the_standard_message_for_should_be_empty
+    ['foo', 'bar'].should_be_empty
+  end
+  
+  def use_the_provided_message_for_should_be_empty
+    ['foo', 'bar'].should_be_empty("provided for should_be_empty")
+  end
+
+  # should_not_be_empty
+  
+  def use_the_standard_message_for_should_not_be_empty
+    [].should_not_be_empty
+  end
+
+  def use_the_provided_message_for_should_not_be_empty
+    [].should_not_be_empty("provided for should_not_be_empty")
+  end
+
+  # should_include
+  
+  def use_the_standard_message_for_should_include
+    ['foo'].should_include('bar')
+  end
+
+  def use_the_provided_message_for_should_include
+    ['foo'].should_include('bar', "provided for should_include")
+  end
+
+  # should_not_include
+  
+  def use_the_standard_message_for_should_not_include
+    ['foo'].should_not_include('foo')
+  end
+
+  def use_the_provided_message_for_should_not_include
+    ['foo'].should_not_include('foo', "provided for should_not_include")
+  end
+
+  # should_be_true
+  
+  def use_the_standard_message_for_should_be_true
+    false.should_be_true
+  end
+
+  def use_the_provided_message_for_should_be_true
+    false.should_be_true("provided for should_be_true")
+  end
+
+  # should_be_false
+  
+  def use_the_standard_message_for_should_be_false
+    true.should_be_false
+  end
+  
+  def use_the_provided_message_for_should_be_false
+    true.should_be_false("provided for should_be_false")
+  end
+
+end
+
+
+class ErrorReportingRunner
+
+  def initialize
+    @failures = []
+  end
+
+  def pass(spec)
+  end
+
+  def failure(spec, exception)
+    @failures << exception.message
+  end
+
+  def error(spec)
+  end
+
+  def spec(spec)
+  end
+
+  def run(context)
+    context.specifications.each do |example|
+      the_context = context.new(example)
+      the_context.run(self)
+    end
+  end
+
+  def dump_failures
+    @failures
+  end
+
+end
+
+
+class ErrorReportingTest < Test::Unit::TestCase
+
+  def setup
+    @runner = ErrorReportingRunner.new
+    @runner.run(ErrorReportingContext)
+  end
+
+  # should
+
+  def test_should_report_standard_message_for_should
+    assert @runner.dump_failures.include?("Expectation not met.")
+  end
+
+  def test_should_report_provided_message_for_should
+    assert @runner.dump_failures.include?("provided message")
+  end  
+
+  # should_equal
+  
+  def test_should_report_standard_message_for_should_equal
+    assert @runner.dump_failures.include?("<Object>\nshould be equal to:\n<Class>")
+  end
+
+  def test_should_report_provided_message_for_should_equal
+    assert @runner.dump_failures.include?("provided for should_equal")
+  end
+
+  # should_not_equal
+  
+  def test_should_report_standard_message_for_should_not_equal
+    assert @runner.dump_failures.include?("<Object>\nshould not be equal to:\n<Object>")
+  end
+  
+  def test_should_report_provided_message_for_should_not_equal
+    assert @runner.dump_failures.include?("provided for should_not_equal")
+  end
+  
+  # should_be_nil
+  
+  def test_should_report_standard_message_for_should_be_nil
+    assert @runner.dump_failures.include?("<Object> should be nil")
+  end
+  
+  def test_should_report_provided_message_fro_should_be_nil
+    assert @runner.dump_failures.include?("provided for should_be_nil")
+  end
+  
+  # should_not_be_nil
+
+  def test_should_report_standard_message_for_should_not_be_nil
+    assert @runner.dump_failures.include?("<> should not be nil")
+  end
+  
+  def test_should_report_provided_message_for_should_not_be_nil
+    assert @runner.dump_failures.include?("provided for should_not_be_nil")
+  end
+
+  # should_be_empty
+  
+  def test_should_report_standard_message_for_should_be_empty
+    assert @runner.dump_failures.include?('<["foo", "bar"]> should be empty')
+  end
+  
+  def test_should_report_provided_message_for_should_be_empty
+    assert @runner.dump_failures.include?("provided for should_be_empty")
+  end
+  
+  # should_not_be_empty
+
+  def test_should_report_standard_message_for_should_not_be_empty
+    assert @runner.dump_failures.include?("<[]> should not be empty")
+  end
+  
+  def test_should_report_provided_message_for_should_not_be_empty
+    assert @runner.dump_failures.include?("provided for should_not_be_empty")
+  end
+
+  # should_include
+  
+  def test_should_report_standard_message_for_should_include
+    assert @runner.dump_failures.include?('<["foo"]> should include <"bar">')
+  end
+  
+  def test_should_report_provided_message_for_should_include
+    assert @runner.dump_failures.include?("provided for should_include")
+  end
+  
+  # should_not_include
+
+  def test_should_report_standard_message_for_should_not_include
+    assert @runner.dump_failures.include?('<["foo"]> should not include <"foo">')
+  end
+
+  def test_should_report_provided_message_for_should_not_include
+    assert @runner.dump_failures.include?("provided for should_not_include")
+  end
+  
+  # should_be_true
+
+  def test_should_report_standard_message_for_should_be_true
+    assert @runner.dump_failures.include?("<false> should be true")
+  end
+
+  def test_should_report_provided_message_for_should_be_true
+    assert @runner.dump_failures.include?("provided for should_be_true")
+  end
+  
+  # should_be_false
+
+  def test_should_report_standard_message_for_should_be_false
+    assert @runner.dump_failures.include?("<true> should be false")
+  end
+
+  def test_should_report_provided_message_for_should_be_false
+    assert @runner.dump_failures.include?("provided for should_be_false")
+  end
+
+end

data/test/expectations_test.rb

@@ -0,0 +1,399 @@
+require 'test/unit'
+
+require 'spec'
+
+
+class DummyObject
+
+  def initialize(foo)
+    @foo = foo
+  end
+
+end
+
+
+class ExpectationsTest < Test::Unit::TestCase
+
+  def setup
+    @dummy = 'dummy'
+    @equal_dummy = 'dummy'
+    @another_dummy  = 'another_dummy'
+    @nil_var = nil
+  end
+
+  # should
+  
+  def test_should_raise_exception_when_block_yields_false
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      should do
+        false
+      end
+    end
+  end
+  
+  def test_should_not_raise_exception_when_block_yields_true
+    assert_nothing_raised do
+      should do
+        true
+      end
+    end
+  end
+
+  # should_equal
+  
+  def test_should_equal_should_not_raise_when_objects_are_equal
+    assert_nothing_raised do
+      @dummy.should_equal(@equal_dummy)
+    end
+  end
+  
+  def test_should_equal_should_raise_when_objects_are_not_equal
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      @dummy.should_equal(@another_dummy)
+    end
+  end
+
+  # should_not_equal
+
+  def test_should_not_equal_should_not_raise_when_objects_are_not_equal
+    assert_nothing_raised do
+      @dummy.should_not_equal(@another_dummy)
+    end
+  end
+
+  def test_should_not_equal_should_raise_when_objects_are_not_equal
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      @dummy.should_not_equal(@equal_dummy)
+    end
+  end
+
+  # should_be_same_as
+
+  def test_should_be_same_as_should_not_raise_when_objects_are_same
+    assert_nothing_raised do
+      @dummy.should_be_same_as(@dummy)
+    end
+  end
+
+  def test_should_be_same_as_should_raise_when_objects_are_not_same
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      @dummy.should_be_same_as(@equal_dummy)
+    end
+  end
+
+  # should_not_be_same_as
+
+  def test_should_not_be_same_as_should_not_raise_when_objects_are_not_same
+    assert_nothing_raised do
+      @dummy.should_not_be_same_as(@equal_dummy)
+    end
+  end
+
+  def test_should_not_be_same_as_should_raise_when_objects_are_not_same
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      @dummy.should_not_be_same_as(@dummy)
+    end
+  end
+
+  # should_be_nil
+
+  def test_should_be_nil_should_not_raise_when_object_is_nil
+    assert_nothing_raised do
+      @nil_var.should_be_nil
+    end  
+  end
+
+  def test_should_be_nil_should_raise_when_object_is_not_nil
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      @dummy.should_be_nil
+    end
+  end
+  
+  # should_not_be_nil
+
+  def test_should_not_be_nil_should_not_raise_when_object_is_not_nil
+    assert_nothing_raised do
+      @dummy.should_not_be_nil
+    end  
+  end
+
+  def test_should_not_be_nil_should_raise_when_object_is_nil
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      @nil_var.should_not_be_nil
+    end
+  end
+      
+  # should_be_empty
+
+  def test_should_be_empty_should_raise_when_object_is_not_a_container
+    assert_raise(NoMethodError) do
+      5.should_be_empty
+    end
+  end
+
+  def test_should_be_empty_should_raise_when_object_is_a_non_empty_array
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      [1, 2, 3].should_be_empty
+    end
+  end
+
+  def test_should_be_empty_shouldnt_raise_when_object_is_an_empty_array
+    assert_nothing_raised do
+      [].should_be_empty
+    end
+  end
+
+  def test_should_be_empty_should_raise_when_object_is_a_non_empty_hash
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      {"a" => 1}.should_be_empty
+    end
+  end
+
+  def test_should_be_empty_shouldnt_raise_when_object_is_an_empty_hash
+    assert_nothing_raised do
+      {}.should_be_empty
+    end
+  end
+  
+  # should_not_be_empty
+
+  def test_should_be_empty_should_raise_when_object_is_a_non_empty_string
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      @dummy.should_be_empty
+    end
+  end
+
+  def test_should_be_empty_shouldnt_raise_when_object_is_an_empty_string
+    assert_nothing_raised do
+      "".should_be_empty
+    end
+  end
+
+  def test_should_not_be_empty_should_raise_when_object_is_not_a_container
+    assert_raise(NoMethodError) do
+      5.should_not_be_empty
+    end
+  end
+
+  def test_should_not_be_empty_should_raise_when_object_is_an_empty_array
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      [].should_not_be_empty
+    end
+  end
+
+  def test_should_not_be_empty_shouldnt_raise_when_object_is_a_non_empty_array
+    assert_nothing_raised do
+      [1, 2, 3].should_not_be_empty
+    end
+  end
+
+  def test_should_not_be_empty_should_raise_when_object_is_an_empty_hash
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      {}.should_not_be_empty
+    end
+  end
+
+  def test_should_not_be_empty_shouldnt_raise_when_object_is_a_non_empty_hash
+    assert_nothing_raised do
+      {"a"=>1}.should_not_be_empty
+    end
+  end
+
+  def test_should_not_be_empty_should_raise_when_object_is_an_empty_string
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      "".should_not_be_empty
+    end
+  end
+
+  def test_should_not_be_empty_shouldnt_raise_when_object_is_a_non_empty_string
+    assert_nothing_raised do
+      @dummy.should_not_be_empty
+    end
+  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(Spec::Exceptions::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(Spec::Exceptions::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 test_should_include_should_raise_when_hash_inclusion_is_missing
+    assert_raise(Spec::Exceptions::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(Spec::Exceptions::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(Spec::Exceptions::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(Spec::Exceptions::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(Spec::Exceptions::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(Spec::Exceptions::ExpectationNotMetError) do
+      IO.constants.should_not_include("SEEK_SET")
+    end
+  end
+  
+  # violated
+  
+  def test_violated_should_raise
+    assert_raise  (Spec::Exceptions::ExpectationNotMetError) do
+      c = Spec::Context.new
+      c.violated
+    end
+  end
+  
+  # should_be_true
+  
+  def test_should_be_true_should_raise_when_object_is_nil
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      nil.should_be_true
+    end
+  end
+  
+  def test_should_be_true_should_raise_when_object_is_false
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      false.should_be_true
+    end
+  end
+
+  def test_should_be_true_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
+    assert_nothing_raised do
+      5.should_be_true
+    end
+  end
+  
+  def test_should_be_true_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
+    assert_nothing_raised do
+      self.should_be_true
+    end
+  end
+
+  # should_be_false
+
+  def test_should_be_true_shouldnt_raise_when_object_is_nil
+    assert_nothing_raised do
+      nil.should_be_false
+    end
+  end
+
+  def test_should_be_true_shouldnt_raise_when_object_is_false
+    assert_nothing_raised do
+      false.should_be_false
+    end
+  end
+
+  def test_should_be_true_should_raise_when_object_is_true
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      true.should_be_false
+    end
+  end
+
+  def test_should_be_true_shouldnt_raise_when_object_is_a_number
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      5.should_be_false
+    end
+  end
+
+  def test_should_be_true_shouldnt_raise_when_object_is_a_string
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      "hello".should_be_false
+    end
+  end
+
+  def test_should_be_true_shouldnt_raise_when_object_is_a_some_random_object
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      self.should_be_false
+    end
+  end
+
+end