baretest 0.1.0

data/test/lib/test/assertion/support.rb

@@ -0,0 +1,240 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  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."
+      end
+
+      true
+    end
+  end
+end
+
+Test.define "Test" do
+  suite "Assertion" do
+    suite "Support" do
+      suite "#raises" do
+        assert "Should not fail when used without argument and the block raises an exception derived from StandardError." do
+          raises do raise "foo" end
+        end
+
+        assert "Should not fail when the block raises an exception derived from the provided exception-class." do
+          raises(ArgumentError) do raise ArgumentError, "foo" end
+        end
+
+        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
+            true
+          else
+            false
+          end
+        end
+
+        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
+            true
+          else
+            false
+          end
+        end
+      end # raises
+
+      suite "#raises_nothing" do
+        assert "Should not fail when the block doesn't raise." do
+          raises_nothing do; end
+        end
+
+        assert "Should fail when the block raises." do
+          begin
+            raises_nothing do raise "anything" end
+          rescue ::Test::Assertion::Failure
+            true
+          else
+            false
+          end
+        end
+      end
+
+      suite "#touch/#touched" do
+        suite "When you don't touch(x), touched(x) should fail" do
+          assert "When you don't touch at all, touched(x) should fail" do
+            fails do
+              touched :foo1
+            end
+          end
+
+          assert "When you don't touch something else, touched(x) should fail" do
+            fails do
+              touch :bar2
+              touched :foo2
+            end
+          end
+        end
+
+        suite "When you touch(x), touched(x) should not fail" do
+          assert "When you touch(x), touched(x) should be true" do
+            touch :foo3
+            touched :foo3
+          end
+
+          assert "When you touch(x) multiple times, touched(x) should be true" do
+            3.times { touch :foo4 }
+            touched :foo4
+          end
+        end
+
+        suite "Touching in one assertion shouldn't carry over to another assertion" do
+          assert "Touch x. Preparation for next assertion" do
+            touch(:foo5)
+          end
+
+          assert "No touch x, touched x should raise." do
+            fails do touched(:foo5) end
+          end
+        end
+      end # #touch/#touched
+
+      suite "#within_delta" do
+        assert "Should not fail when the value is within the delta." do
+          within_delta(3.0, 3.01, 0.02)
+        end
+
+        assert "Should fail when the value is not within the delta." do
+          fails do
+            within_delta(3.0, 3.03, 0.02)
+          end
+        end
+      end # within_delta
+
+      suite "#equal_unordered" do
+        assert "Should not fail when the two arrays contain the same items the same number of times." do
+          equal_unordered([1,2,3], [3,1,2])
+        end
+
+        assert "Should fail when the two arrays don't contain the same items." do
+          fails do
+            equal_unordered([1,2,3], [5,6,1])
+          end
+        end
+
+        assert "Should fail when the two arrays contain the same items a different number of times." do
+          fails do
+            equal_unordered([1,2,3], [3,1,2,2])
+          end
+        end
+      end # equal_unordered
+
+      suite "#same" do
+        assert "Should not fail when the values are the same object." do
+          a = "foo"
+          same(a, a)
+        end
+
+        assert "Should fail when the values are not the same object." do
+          fails do
+            same("a", "b")
+          end
+        end
+      end # same
+
+      suite "#order_equal" do
+        assert "Should not fail when the values are equal by ==." do
+          order_equal(1, 1.0)
+        end
+
+        assert "Should fail when the values are not equal by ==." do
+          fails do
+            order_equal(1, 1.1)
+          end
+        end
+      end # order_equal
+
+      suite "#hash_key_equal" do
+        assert "Should not fail when the values are the same object." do
+          hash_key_equal("foo", "foo")
+        end
+
+        assert "Should fail when the values are not the same object." do
+          fails do
+            hash_key_equal("foo", "bar")
+          end
+        end
+      end # hash_key_equal
+
+      suite "#case_equal" do
+        assert "Should not fail when the values are the same object." do
+          case_equal(String, "foo")
+        end
+
+        assert "Should fail when the values are not the same object." do
+          fails do
+            case_equal(String, [])
+          end
+        end
+      end # case_equal
+
+      suite "#kind_of" do
+        assert "Should not fail when the value is an instance of the given class" do
+          kind_of(Array, [])
+        end
+
+        assert "Should not fail when the value is an instance of a subclass of the given class" do
+          kind_of(Enumerable, [])
+        end
+
+        assert "Should fail when the value is not instance of the given class or subclass" do
+          fails do
+            kind_of(String, [])
+          end
+        end
+      end
+
+      suite "#failure_with_optional_message" do
+        assert "Should raise a Test::Assertion::Failure" do
+          raises(::Test::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
+            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
+            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
+            failure "Should raise that exception."
+          end
+        end
+      end
+    end # Support
+  end # Assertion
+end # Test

data/test/lib/test/assertion.rb

@@ -0,0 +1,142 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+Test.define "Test" do
+  suite "Assertion" do
+    suite "::new" do
+      assert "Should return a ::Test::Assertion instance" do
+        ::Test::Assertion.new(nil, "description") { nil }.class ==
+        ::Test::Assertion
+      end
+
+      assert "Should expect exactly 2 arguments" do
+        raises(ArgumentError) { ::Test::Assertion.new() } &&
+        raises(ArgumentError) { ::Test::Assertion.new(nil) } &&
+        raises(ArgumentError) { ::Test::Assertion.new(nil, "foo", "bar") }
+      end
+    end
+
+    suite "#status" do
+      assert "A new Assertion should have a status of nil" do
+        ::Test::Assertion.new(nil, "description") {}.status.nil?
+      end
+
+      assert "Executing an assertion with a block that returns true should be :success" do
+        assertion_success = ::Test::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 = ::Test::Assertion.new(nil, "description") { false }
+        assertion_success.execute
+        assertion_success.status == :failure
+      end
+
+      assert "Executing an assertion with a block that raises should be :error" do
+        assertion_success = ::Test::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 = ::Test::Assertion.new(nil, "description")
+        assertion_success.execute
+
+        same :expected => :pending, :actual => assertion_success.status
+      end
+    end
+
+    suite "#exception" do
+      assert "An assertion that doesn't raise should have nil as exception" do
+        assertion_success = ::Test::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   = ::Test::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     = ::Test::Suite.new
+        assertion = ::Test::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 = ::Test::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    = ::Test::Suite.new("block1") do setup(&block1) end
+        suite2    = ::Test::Suite.new("suite2", suite1) do setup(&block2) end
+        assertion = ::Test::Assertion.new(suite2, "assertion")
+
+        raises_nothing do assertion.setup end &&
+        equal([:block1, :block2], executed)
+      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    = ::Test::Suite.new("block1") do teardown(&block1) end
+        suite2    = ::Test::Suite.new("suite2", suite1) do teardown(&block2) end
+        assertion = ::Test::Assertion.new(suite2, "assertion")
+
+        raises_nothing do assertion.teardown end &&
+        equal([:block2, :block1], executed)
+      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 = ::Test::Assertion.new(nil, "") { this.touch(:execute) }
+        assertion.execute
+        touched(:execute)
+      end
+    end
+
+    suite "#clean_copy" do
+      assert "Should return an instance of Test::Assertion" do
+        kind_of(::Test::Assertion, ::Test::Assertion.new("", nil).clean_copy)
+      end
+
+      assert "Should have the same description, suite and block" do
+        description = "description"
+        suite       = ::Test::Suite.new
+        block       = proc { true }
+        assertion1  = ::Test::Assertion.new(description, suite, &block)
+        assertion2  = assertion1.clean_copy
+
+        same(assertion1.description, assertion2.description, "description") &&
+        same(assertion1.suite, assertion2.suite, "suite") &&
+        same(assertion1.block, assertion2.block, "block")
+      end
+    end
+  end
+end

data/test/lib/test/debug.rb

@@ -0,0 +1,63 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+Test.define "Test with test/debug", :requires => 'test/debug' do
+  suite "Assertion with test/debug", :requires => 'test/debug' do
+    suite "#to_s" do
+      assert "Assertion should have a to_s which contains the classname and the description" do
+        description  = "the description"
+        assertion    = Test::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          = Test::Suite.new
+        description    = "the description"
+        assertion      = Test::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
+
+  suite "Suite with test/debug", :requires => 'test/debug' do
+    suite "#to_s" do
+      assert "Suite should have a to_s which contains the classname and the description" do
+        description  = "the description"
+        suite        = Test::Suite.new(description)
+        print_string = suite.to_s
+
+        print_string.include?(suite.class.name) &&
+        print_string.include?(description)
+      end
+    end
+
+    suite "#inspect" do
+      assert "Suite should have an inspect which contains the classname, the shifted object-id in zero-padded hex and the description's inspect" do
+        description    = "the description"
+        suite          = Test::Suite.new(description)
+        inspect_string = suite.inspect
+
+        inspect_string.include?(suite.class.name) &&
+        inspect_string.include?("%08x" % (suite.object_id >> 1)) &&
+        inspect_string.include?(description.inspect)
+      end
+    end
+  end
+end

data/test/lib/test/irb_mode.rb

@@ -0,0 +1,10 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# If you got a viable idea on how to test this, mail me, I'll owe you a beer.
+# Maybe I should mock IRB and expect the setup to happen for failing/erroring assertions

data/test/lib/test/run/cli.rb

@@ -0,0 +1,9 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# Not yet testing runners

data/test/lib/test/run/errors.rb

@@ -0,0 +1,9 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# Not yet testing runners

data/test/lib/test/run/interactive.rb

@@ -0,0 +1,9 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# Not yet testing runners

data/test/lib/test/run/spec.rb

@@ -0,0 +1,9 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# Not yet testing runners

data/test/lib/test/run/tap.rb

@@ -0,0 +1,9 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# Not yet testing runners

data/test/lib/test/run/xml.rb

@@ -0,0 +1,9 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# Not yet testing runners