baretest 0.1.0 → 0.2.3

data/test/external/bootstraptest.rb

@@ -1,4 +1,4 @@
-Test.run_if_mainfile do
+BareTest.run_if_mainfile do
   assert "Sample assert" do
     true
   end

data/test/setup.rb

@@ -1,2 +1,2 @@
 $LOAD_PATH.unshift(File.expand_path("#{__FILE__}/../../lib"))
-require 'test'
+require 'baretest'

data/test/{lib/test → suite/lib/baretest}/assertion/support.rb

@@ -6,26 +6,28 @@
 
 
 
-module Test
+module BareTest
   class Assertion
-    # used here to test for failure
-    def fails # :nodoc:
-      failed = false
-      begin
-        failed = !yield
-      rescue Test::Assertion::Failure
-        failed = true
-      end
-      unless failed then
-        failure "Expected the block to fail, but it returned a true value."
+    class Context
+      # used here to test for failure
+      def fails # :nodoc:
+        failed = false
+        begin
+          failed = !yield
+        rescue ::BareTest::Assertion::Failure
+          failed = true
+        end
+        unless failed then
+          failure "Expected the block to fail, but it returned a true value."
+        end
+  
+        true
       end
-
-      true
     end
   end
 end
 
-Test.define "Test" do
+BareTest.suite "BareTest" do
   suite "Assertion" do
     suite "Support" do
       suite "#raises" do
@@ -40,7 +42,7 @@ Test.define "Test" do
         assert "Should fail when used without argument and the block doesn't raise." do
           begin
             raises do "nothing raised -> should fail" end
-          rescue ::Test::Assertion::Failure
+          rescue ::BareTest::Assertion::Failure
             true
           else
             false
@@ -50,7 +52,7 @@ Test.define "Test" do
         assert "Should fail when the block raises an exception not derived from the provided exception-class." do
           begin
             raises(TypeError) do raise ArgumentError, "different class -> should fail" end
-          rescue ::Test::Assertion::Failure
+          rescue ::BareTest::Assertion::Failure
             true
           else
             false
@@ -66,7 +68,7 @@ Test.define "Test" do
         assert "Should fail when the block raises." do
           begin
             raises_nothing do raise "anything" end
-          rescue ::Test::Assertion::Failure
+          rescue ::BareTest::Assertion::Failure
             true
           else
             false
@@ -123,6 +125,12 @@ Test.define "Test" do
             within_delta(3.0, 3.03, 0.02)
           end
         end
+
+        assert "Should fail with invalid input." do
+          fails do
+            within_delta(nil, nil, 0.02)
+          end
+        end
       end # within_delta
 
       suite "#equal_unordered" do
@@ -141,6 +149,12 @@ Test.define "Test" do
             equal_unordered([1,2,3], [3,1,2,2])
           end
         end
+
+        assert "Should fail with invalid input." do
+          fails do
+            equal_unordered(nil, nil)
+          end
+        end
       end # equal_unordered
 
       suite "#same" do
@@ -154,6 +168,14 @@ Test.define "Test" do
             same("a", "b")
           end
         end
+
+        assert "Should fail with invalid input." do
+          fails do
+            x = Class.new do undef equal? end # really, who does that?
+            y = x.new
+            equal_unordered(y, y)
+          end
+        end
       end # same
 
       suite "#order_equal" do
@@ -166,6 +188,14 @@ Test.define "Test" do
             order_equal(1, 1.1)
           end
         end
+
+        assert "Should fail with invalid input." do
+          fails do
+            x = Class.new do undef == end
+            y = x.new
+            order_equal(y, y)
+          end
+        end
       end # order_equal
 
       suite "#hash_key_equal" do
@@ -178,6 +208,14 @@ Test.define "Test" do
             hash_key_equal("foo", "bar")
           end
         end
+
+        assert "Should fail with invalid input." do
+          fails do
+            x = Class.new do undef eql? end
+            y = x.new
+            hash_key_equal(y, y)
+          end
+        end
       end # hash_key_equal
 
       suite "#case_equal" do
@@ -190,6 +228,14 @@ Test.define "Test" do
             case_equal(String, [])
           end
         end
+
+        assert "Should fail with invalid input." do
+          fails do
+            x = Class.new do undef === end
+            y = x.new
+            case_equal(y, y)
+          end
+        end
       end # case_equal
 
       suite "#kind_of" do
@@ -209,32 +255,40 @@ Test.define "Test" do
       end
 
       suite "#failure_with_optional_message" do
-        assert "Should raise a Test::Assertion::Failure" do
-          raises(::Test::Assertion::Failure) do
+        assert "Should raise a BareTest::Assertion::Failure" do
+          raises(::BareTest::Assertion::Failure) do
             failure_with_optional_message "With %s", "Without message", "message"
           end
         end
 
         assert "Should use the string with message if message is given" do
-          raises(::Test::Assertion::Failure, :with_message => "With message") do
+          raises(::BareTest::Assertion::Failure, :with_message => "With message") do
             failure_with_optional_message "With %s", "Without message", "message"
           end
         end
 
         assert "Should use the string without message if no message is given" do
-          raises(::Test::Assertion::Failure, :with_message => "Without message") do
+          raises(::BareTest::Assertion::Failure, :with_message => "Without message") do
             failure_with_optional_message "With %s", "Without message", nil
           end
         end
       end
 
       suite "#failure" do
-        assert "Should raise a Test::Assertion::Failure." do
-          raises(::Test::Assertion::Failure) do
+        assert "Should raise a BareTest::Assertion::Failure." do
+          raises(::BareTest::Assertion::Failure) do
             failure "Should raise that exception."
           end
         end
       end
+
+      suite "#skip" do
+        assert "Should raise a BareTest::Assertion::Skip." do
+          raises(::BareTest::Assertion::Skip) do
+            skip "Should raise that exception."
+          end
+        end
+      end
     end # Support
   end # Assertion
-end # Test
+end # BareTest

data/test/suite/lib/baretest/assertion.rb

@@ -0,0 +1,192 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+BareTest.suite "BareTest" do
+  suite "Assertion" do
+    suite "::new" do
+      assert "Should return a ::BareTest::Assertion instance" do
+        ::BareTest::Assertion.new(nil, "description") { nil }.class ==
+        ::BareTest::Assertion
+      end
+
+      assert "Should expect exactly 2 arguments" do
+        raises(ArgumentError) { ::BareTest::Assertion.new() } &&
+        raises(ArgumentError) { ::BareTest::Assertion.new(nil) } &&
+        raises(ArgumentError) { ::BareTest::Assertion.new(nil, "foo", "bar") }
+      end
+    end
+
+    suite "#status" do
+      assert "A new Assertion should have a status of nil" do
+        ::BareTest::Assertion.new(nil, "description") {}.status.nil?
+      end
+
+      assert "Executing an assertion with a block that returns true should be :success" do
+        assertion_success = ::BareTest::Assertion.new(nil, "description") { true }
+        assertion_success.execute
+        assertion_success.status == :success
+      end
+
+      assert "Executing an assertion with a block that returns false should be :failure" do
+        assertion_success = ::BareTest::Assertion.new(nil, "description") { false }
+        assertion_success.execute
+        assertion_success.status == :failure
+      end
+
+      assert "Executing an assertion with a block that raises a Failure should be :failure" do
+        assertion_success = ::BareTest::Assertion.new(nil, "description") { raise ::BareTest::Assertion::Failure, "just fail" }
+        assertion_success.execute
+        assertion_success.status == :failure
+      end
+
+      assert "Executing an assertion with a block that raises should be :error" do
+        assertion_success = ::BareTest::Assertion.new(nil, "description") { raise }
+        assertion_success.execute
+        assertion_success.status == :error
+      end
+
+      assert "Executing an assertion without a block should be :pending" do
+        assertion_success = ::BareTest::Assertion.new(nil, "description")
+        assertion_success.execute
+
+        same :expected => :pending, :actual => assertion_success.status
+      end
+
+      assert "Executing an assertion with a block that raises a Skip should be :skipped" do
+        assertion_success = ::BareTest::Assertion.new(nil, "description") { raise ::BareTest::Assertion::Skip, "just skip" }
+        assertion_success.execute
+        assertion_success.status == :skipped
+      end
+    end
+
+    suite "meta information" do
+      assert "An assertion should have a valid line number and file" do
+        suite = ::BareTest::Suite.new
+        assertion = suite.assert do true end
+
+        assertion[0].line && assertion[0].file
+      end
+    end
+
+    suite "#exception" do
+      assert "An assertion that doesn't raise should have nil as exception" do
+        assertion_success = ::BareTest::Assertion.new(nil, "description") { true }
+        assertion_success.execute
+        same :expected => nil, :actual => assertion_success.exception
+      end
+    end
+
+    suite "#description" do
+      assert "An assertion should have a description" do
+        description = "The assertion description"
+        assertion   = ::BareTest::Assertion.new(nil, description) { true }
+        same :expected => description, :actual => assertion.description
+      end
+    end
+
+    suite "#suite" do
+      assert "An assertion can belong to a suite" do
+        suite     = ::BareTest::Suite.new
+        assertion = ::BareTest::Assertion.new(suite, "") { true }
+        same :expected => suite, :actual => assertion.suite
+      end
+    end
+
+    suite "#block" do
+      assert "An assertion can have a block" do
+        block     = proc { true }
+        assertion = ::BareTest::Assertion.new(nil, "", &block)
+        same :expected => block, :actual => assertion.block
+      end
+    end
+
+    suite "#setup" do
+      assert "Should run all enclosing suite's setup blocks, outermost first" do
+        executed  = []
+        block1    = proc { executed << :block1 }
+        block2    = proc { executed << :block2 }
+        suite1    = ::BareTest::Suite.new("block1") do setup(&block1) end
+        suite2    = ::BareTest::Suite.new("suite2", suite1) do setup(&block2) end
+        assertion = ::BareTest::Assertion.new(suite2, "assertion")
+
+        raises_nothing do assertion.setup end &&
+        equal([:block1, :block2], executed)
+      end
+
+      assert "Should fail if setup raises an exception" do
+        block     = proc { raise "Some error" }
+        suite     = ::BareTest::Suite.new("block") do setup(&block) end
+        assertion = ::BareTest::Assertion.new(suite, "assertion") do true end
+
+        assertion.execute
+
+        equal(:error, assertion.status, "assertion.status")
+      end
+    end
+
+    suite "#teardown" do
+      assert "Should run all enclosing suite's teardown blocks, innermost first" do
+        executed  = []
+        block1    = proc { executed << :block1 }
+        block2    = proc { executed << :block2 }
+        suite1    = ::BareTest::Suite.new("block1") do teardown(&block1) end
+        suite2    = ::BareTest::Suite.new("suite2", suite1) do teardown(&block2) end
+        assertion = ::BareTest::Assertion.new(suite2, "assertion")
+
+        raises_nothing do assertion.teardown end &&
+        equal([:block2, :block1], executed)
+      end
+
+      assert "Should fail if teardown raises an exception" do
+        block     = proc { raise "Some error" }
+        suite     = ::BareTest::Suite.new("block") do teardown(&block) end
+        assertion = ::BareTest::Assertion.new(suite, "assertion") do true end
+
+        assertion.execute
+
+        assertion.status == :error
+      end
+    end
+
+    suite "#execute" do
+      assert "Execute will run the assertion's block" do
+        this      = self # needed because touch is called in the block of another assertion, so otherwise it'd be local to that assertion
+        assertion = ::BareTest::Assertion.new(nil, "") { this.touch(:execute) }
+        assertion.execute
+        touched(:execute)
+      end
+    end
+
+    suite "#to_s" do
+      assert "Assertion should have a to_s which contains the classname and the description" do
+        description  = "the description"
+        assertion    = ::BareTest::Assertion.new(nil, description)
+        print_string = assertion.to_s
+
+        print_string.include?(assertion.class.name) &&
+        print_string.include?(description)
+      end
+    end
+
+    suite "#inspect" do
+      assert "Assertion should have an inspect which contains the classname, the shifted object-id in zero-padded hex, the suite's inspect and the description's inspect" do
+        suite          = ::BareTest::Suite.new
+        description    = "the description"
+        assertion      = ::BareTest::Assertion.new(suite, description)
+        def suite.inspect; "<inspect of suite>"; end
+
+        inspect_string = assertion.inspect
+
+        inspect_string.include?(assertion.class.name) &&
+        inspect_string.include?("%08x" % (assertion.object_id >> 1)) &&
+        inspect_string.include?(suite.inspect) &&
+        inspect_string.include?(description.inspect)
+      end
+    end
+  end
+end