baretest 0.1.0 → 0.2.3

data/test/{lib/test → suite/lib/baretest}/run.rb

@@ -6,39 +6,39 @@
 
 
 
-Test.define "Test" do
+BareTest.suite "BareTest" do
   suite "Run" do
     suite "::new" do
       assert "Should return an instance of Run" do
-        kind_of ::Test::Run, ::Test::Run.new(::Test::Suite.new)
+        kind_of ::BareTest::Run, ::BareTest::Run.new(::BareTest::Suite.new)
       end
 
       assert "Should accept 1-2 arguments" do
-        raises(ArgumentError) do ::Test::Run.new end &&
-        raises_nothing do ::Test::Run.new(::Test::Suite.new) end &&
-        raises_nothing do ::Test::Run.new(::Test::Suite.new, {}) end &&
-        raises(ArgumentError) do ::Test::Run.new(::Test::Suite.new, {}, nil) end
+        raises(ArgumentError) do ::BareTest::Run.new end &&
+        raises_nothing do ::BareTest::Run.new(::BareTest::Suite.new) end &&
+        raises_nothing do ::BareTest::Run.new(::BareTest::Suite.new, {}) end &&
+        raises(ArgumentError) do ::BareTest::Run.new(::BareTest::Suite.new, {}, nil) end
       end
 
       assert "Should accept an option ':format'" do
-        raises_nothing do ::Test::Run.new(::Test::Suite.new, :format => 'spec') end
+        raises_nothing do ::BareTest::Run.new(::BareTest::Suite.new, :format => 'spec') end
       end
 
       assert "Should use the formatter specified in the :format option" do
-        run = ::Test::Run.new(::Test::Suite.new, :format => 'spec')
-        kind_of(::Test::Run::Spec, run)
+        run = ::BareTest::Run.new(::BareTest::Suite.new, :format => 'spec')
+        kind_of(::BareTest::Run::Spec, run)
       end
 
       assert "Should accept an option ':interactive' and load irb_mode" do
-        run = ::Test::Run.new(::Test::Suite.new, :interactive => true)
-        kind_of(::Test::IRBMode, run)
+        run = ::BareTest::Run.new(::BareTest::Suite.new, :interactive => true)
+        kind_of(::BareTest::IRBMode, run)
       end
     end
 
     suite "#suite" do
       assert "Should return the suite the instance was initialized with" do
-        suite = ::Test::Suite.new
-        run   = ::Test::Run.new(suite)
+        suite = ::BareTest::Suite.new
+        run   = ::BareTest::Run.new(suite)
 
         same(suite, run.suite)
       end
@@ -46,7 +46,7 @@ Test.define "Test" do
 
     suite "#inits" do
       setup do
-        Test.extender.clear # avoid interference
+        BareTest.extender.clear # avoid interference
         @executed    = []
         executed     = @executed # for closure
         @init_blocks = [
@@ -61,17 +61,17 @@ Test.define "Test" do
             }
           end
         end
-        $LOADED_FEATURES << 'test/run/test_init.rb' unless $LOADED_FEATURES.include?('test/run/test_init.rb') # suppress require
-        ::Test.format['test/run/test_init'] = @extender # provide the module as formatter
+        $LOADED_FEATURES << 'baretest/run/test_init.rb' unless $LOADED_FEATURES.include?('baretest/run/test_init.rb') # suppress require
+        ::BareTest.format['baretest/run/test_init'] = @extender # provide the module as formatter
       end
 
       assert "Should return the array with blocks called at the end of initialize" do
-        run = ::Test::Run.new(::Test::Suite.new, :format => 'test_init')
+        run = ::BareTest::Run.new(::BareTest::Suite.new, :format => 'test_init')
         equal(@init_blocks, run.inits)
       end
 
       assert "Should run the blocks at the end of initialize" do
-        run = ::Test::Run.new(::Test::Suite.new, :format => 'test_init')
+        run = ::BareTest::Run.new(::BareTest::Suite.new, :format => 'test_init')
         equal([:block1, :block2], @executed)
       end
     end
@@ -84,10 +84,10 @@ Test.define "Test" do
             invoked_suites << suite
           end
         end
-        toplevel_suite = ::Test::Suite.new
-        $LOADED_FEATURES << 'test/run/test_init.rb' unless $LOADED_FEATURES.include?('test/run/test_init.rb') # suppress require
-        ::Test.format['test/run/test_init'] = extender # provide the module as formatter
-        run = ::Test::Run.new(toplevel_suite, :format => 'test_init')
+        toplevel_suite = ::BareTest::Suite.new
+        $LOADED_FEATURES << 'baretest/run/test_init.rb' unless $LOADED_FEATURES.include?('baretest/run/test_init.rb') # suppress require
+        ::BareTest.format['baretest/run/test_init'] = extender # provide the module as formatter
+        run = ::BareTest::Run.new(toplevel_suite, :format => 'test_init')
         run.run_all
 
         equal([toplevel_suite], invoked_suites)
@@ -103,45 +103,47 @@ Test.define "Test" do
             super(suite)
           end
         end
+
         suites = [
-          ::Test::Suite.new,
-          ::Test::Suite.new
+          ["desc1", ::BareTest::Suite.new],
+          ["desc2", ::BareTest::Suite.new]
         ]
-        toplevel_suite = ::Test::Suite.new
+        toplevel_suite = ::BareTest::Suite.new
         toplevel_suite.suites.concat(suites) # HAX, should have an API for this
-        suites.unshift(toplevel_suite)
-        $LOADED_FEATURES << 'test/run/test_init.rb' unless $LOADED_FEATURES.include?('test/run/test_init.rb') # suppress require
-        ::Test.format['test/run/test_init'] = extender # provide the module as formatter
-        run = ::Test::Run.new(toplevel_suite, :format => 'test_init')
+        expect = [toplevel_suite]+suites.map { |desc, suite| suite }
+
+        $LOADED_FEATURES << 'baretest/run/test_init.rb' unless $LOADED_FEATURES.include?('baretest/run/test_init.rb') # suppress require
+        ::BareTest.format['baretest/run/test_init'] = extender # provide the module as formatter
+        run = ::BareTest::Run.new(toplevel_suite, :format => 'test_init')
         run.run_suite(toplevel_suite)
 
-        equal_unordered(suites, invoked_suites)
+        equal_unordered(expect, invoked_suites)
       end
 
       assert "Invokes #run_test with every suite in the given suite" do
         invoked_tests = []
         extender       = Module.new do |m|
-          define_method :run_test do |test|
+          define_method :run_test do |test, setup|
             invoked_tests << test
           end
         end
-        toplevel_suite = ::Test::Suite.new
+        toplevel_suite = ::BareTest::Suite.new
         assertions     = [
-          ::Test::Assertion.new(toplevel_suite, "assertion1"),
-          ::Test::Assertion.new(toplevel_suite, "assertion2")
+          ::BareTest::Assertion.new(toplevel_suite, "assertion1"),
+          ::BareTest::Assertion.new(toplevel_suite, "assertion2")
         ]
-        toplevel_suite.tests.concat(assertions) # HAX, should have an API for this
-        $LOADED_FEATURES << 'test/run/test_init.rb' unless $LOADED_FEATURES.include?('test/run/test_init.rb') # suppress require
-        ::Test.format['test/run/test_init'] = extender # provide the module as formatter
-        run = ::Test::Run.new(toplevel_suite, :format => 'test_init')
+        toplevel_suite.assertions.concat(assertions) # HAX, should have an API for this
+        $LOADED_FEATURES << 'baretest/run/test_init.rb' unless $LOADED_FEATURES.include?('baretest/run/test_init.rb') # suppress require
+        ::BareTest.format['baretest/run/test_init'] = extender # provide the module as formatter
+        run = ::BareTest::Run.new(toplevel_suite, :format => 'test_init')
         run.run_all
 
         equal_unordered(assertions, invoked_tests)
       end
 
       assert "Increments the counter ':suite' at the end" do
-        toplevel_suite = ::Test::Suite.new
-        run = ::Test::Run.new(toplevel_suite)
+        toplevel_suite = ::BareTest::Suite.new
+        run = ::BareTest::Run.new(toplevel_suite)
 
         count_before = run.count[:suite]
         run.run_suite(toplevel_suite)
@@ -154,18 +156,18 @@ Test.define "Test" do
     suite "#run_test" do
       assert "Runs the given test" do
         # should implement this with a mock, expecting #execute to be called
-        assertion = ::Test::Assertion.new(nil, nil) do true end
-        run       = ::Test::Run.new(::Test::Suite.new)
-        run.run_test(assertion)
+        assertion = ::BareTest::Assertion.new(nil, nil) do true end
+        run       = ::BareTest::Run.new(::BareTest::Suite.new)
+        run.run_test(assertion, [])
 
         equal(:success, assertion.status)
       end
 
       assert "Increments the counter ':test' at the end" do
-        assertion = ::Test::Assertion.new(nil, "") do true end
-        run       = ::Test::Run.new(::Test::Suite.new)
+        assertion = ::BareTest::Assertion.new(nil, "") do true end
+        run       = ::BareTest::Run.new(::BareTest::Suite.new)
         count_before = run.count[:test]
-        run.run_test(assertion)
+        run.run_test(assertion, [])
         count_after = run.count[:test]
 
         equal(count_before+1, count_after)
@@ -173,10 +175,10 @@ Test.define "Test" do
 
       suite "The given test was a success" do
         assert "Increments the counter ':success' at the end" do
-          assertion = ::Test::Assertion.new(nil, "") do true end
-          run       = ::Test::Run.new(::Test::Suite.new)
+          assertion = ::BareTest::Assertion.new(nil, "") do true end
+          run       = ::BareTest::Run.new(::BareTest::Suite.new)
           count_before = run.count[:success]
-          run.run_test(assertion)
+          run.run_test(assertion, [])
           count_after = run.count[:success]
 
           equal(count_before+1, count_after)
@@ -185,10 +187,10 @@ Test.define "Test" do
 
       suite "The given test was pending" do
         assert "Increments the counter ':pending' at the end" do
-          assertion = ::Test::Assertion.new(nil, "")
-          run       = ::Test::Run.new(::Test::Suite.new)
+          assertion = ::BareTest::Assertion.new(nil, "")
+          run       = ::BareTest::Run.new(::BareTest::Suite.new)
           count_before = run.count[:pending]
-          run.run_test(assertion)
+          run.run_test(assertion, [])
           count_after = run.count[:pending]
 
           equal(count_before+1, count_after)
@@ -197,10 +199,10 @@ Test.define "Test" do
 
       suite "The given test was skipped" do
         assert "Increments the counter ':skipped' at the end" do
-          assertion = ::Test::Skipped::Assertion.new(nil, "")
-          run       = ::Test::Run.new(::Test::Suite.new)
+          assertion = ::BareTest::Skipped::Assertion.new(nil, "")
+          run       = ::BareTest::Run.new(::BareTest::Suite.new)
           count_before = run.count[:skipped]
-          run.run_test(assertion)
+          run.run_test(assertion, [])
           count_after = run.count[:skipped]
 
           equal(count_before+1, count_after)
@@ -209,10 +211,10 @@ Test.define "Test" do
 
       suite "The given test was failure" do
         assert "Increments the counter ':failure' at the end" do
-          assertion = ::Test::Assertion.new(nil, "") do false end
-          run       = ::Test::Run.new(::Test::Suite.new)
+          assertion = ::BareTest::Assertion.new(nil, "") do false end
+          run       = ::BareTest::Run.new(::BareTest::Suite.new)
           count_before = run.count[:failure]
-          run.run_test(assertion)
+          run.run_test(assertion, [])
           count_after = run.count[:failure]
 
           equal(count_before+1, count_after)
@@ -221,10 +223,10 @@ Test.define "Test" do
 
       suite "The given test was error" do
         assert "Increments the counter ':error' at the end" do
-          assertion = ::Test::Assertion.new(nil, "") do raise end
-          run       = ::Test::Run.new(::Test::Suite.new)
+          assertion = ::BareTest::Assertion.new(nil, "") do raise end
+          run       = ::BareTest::Run.new(::BareTest::Suite.new)
           count_before = run.count[:error]
-          run.run_test(assertion)
+          run.run_test(assertion, [])
           count_after = run.count[:error]
 
           equal(count_before+1, count_after)

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

@@ -6,15 +6,15 @@
 
 
 
-Test.define "Test", :requires => 'test/debug' do
+BareTest.suite "BareTest" do
   suite "Assertion" do
     suite "::create" do
       assert "Should accept 0-3 arguments" do
-        raises_nothing { ::Test::Suite.create() } &&
-        raises_nothing { ::Test::Suite.create(nil) } &&
-        raises_nothing { ::Test::Suite.create(nil, nil) } &&
-        raises_nothing { ::Test::Suite.create(nil, nil, {}) } &&
-        raises(ArgumentError) { ::Test::Suite.create(nil, nil, {}, nil) }
+        raises_nothing { ::BareTest::Suite.create() } &&
+        raises_nothing { ::BareTest::Suite.create(nil) } &&
+        raises_nothing { ::BareTest::Suite.create(nil, nil) } &&
+        raises_nothing { ::BareTest::Suite.create(nil, nil, {}) } &&
+        raises(ArgumentError) { ::BareTest::Suite.create(nil, nil, {}, nil) }
       end
 
       assert "Should require a single file listed in :requires option." do
@@ -22,7 +22,7 @@ Test.define "Test", :requires => 'test/debug' do
         original_require = Kernel.instance_method(:require)
         file             = 'foo/bar'
         Kernel.send(:define_method, :require) do |file, *args| a.touch(file) end
-        ::Test::Suite.create(nil, nil, :requires => file)
+        ::BareTest::Suite.create(nil, nil, :requires => file)
         Kernel.send(:define_method, :require, original_require)
 
         touched file
@@ -33,52 +33,52 @@ Test.define "Test", :requires => 'test/debug' do
         original_require = Kernel.instance_method(:require)
         files            = %w[moo/bar moo/baz moo/quuz]
         Kernel.send(:define_method, :require) do |file, *args| a.touch(file) end
-        ::Test::Suite.create(nil, nil, :requires => files)
+        ::BareTest::Suite.create(nil, nil, :requires => files)
         Kernel.send(:define_method, :require, original_require)
 
         files.all? { |file| touched file }
       end
 
-      assert "Should return a ::Test::Suite instance." do
-        ::Test::Suite.create {}.class == ::Test::Suite
+      assert "Should return a ::BareTest::Suite instance." do
+        ::BareTest::Suite.create {}.class == ::BareTest::Suite
       end
 
-      assert "Should return a ::Test::Suite instance without a block." do
-        ::Test::Suite.create.class == ::Test::Skipped::Suite
+      assert "Should return a ::BareTest::Suite instance without a block." do
+        ::BareTest::Suite.create.class == ::BareTest::Skipped::Suite
       end
 
-      assert "Should return a ::Test::Skipped::Suite instance if a required file is not available." do
+      assert "Should return a ::BareTest::Skipped::Suite instance if a required file is not available." do
         original_require = Kernel.instance_method(:require)
         Kernel.send(:define_method, :require) do |*args| raise LoadError end # simulate that the required file was not found
-        return_value = ::Test::Suite.create(nil, nil, :requires => 'fake')
+        return_value = ::BareTest::Suite.create(nil, nil, :requires => 'fake')
         Kernel.send(:define_method, :require, original_require)
 
-        return_value.class == ::Test::Skipped::Suite
+        return_value.class == ::BareTest::Skipped::Suite
       end
     end
 
     suite "::new" do
-      assert "Should return a ::Test::Suite instance" do
-        ::Test::Suite.new(nil, nil).class == ::Test::Suite
+      assert "Should return a ::BareTest::Suite instance" do
+        ::BareTest::Suite.new(nil, nil).class == ::BareTest::Suite
       end
 
       assert "Should accept 0-2 arguments" do
-        raises_nothing { ::Test::Suite.new() } &&
-        raises_nothing { ::Test::Suite.new(nil) } &&
-        raises_nothing { ::Test::Suite.new(nil, nil) } &&
-        raises(ArgumentError) { ::Test::Suite.new(nil, nil, nil) }
+        raises_nothing { ::BareTest::Suite.new() } &&
+        raises_nothing { ::BareTest::Suite.new(nil) } &&
+        raises_nothing { ::BareTest::Suite.new(nil, nil) } &&
+        raises(ArgumentError) { ::BareTest::Suite.new(nil, nil, nil) }
       end
     end
 
     suite "#suites" do
       assert "Should return all the suites defined in the block." do
         expected_descriptions = %w[a b c]
-        suite = ::Test::Suite.new do
+        suite = ::BareTest::Suite.new do
           expected_descriptions.each { |desc|
             suite desc
           }
         end
-        actual_descriptions = suite.suites.map { |child| child.description }
+        actual_descriptions = suite.suites.map { |description, child| description }
 
         equal(
           :expected => 3,
@@ -93,20 +93,20 @@ Test.define "Test", :requires => 'test/debug' do
       end
     end
 
-    suite "#tests" do
+    suite "#assertions" do
       assert "Should return all the suites defined in the block." do
         expected_descriptions = %w[a b c]
-        suite = ::Test::Suite.new do
+        suite = ::BareTest::Suite.new do
           expected_descriptions.each { |desc|
             assert desc
           }
         end
-        actual_descriptions = suite.tests.map { |child| child.description }
+        actual_descriptions = suite.assertions.map { |child| child.description }
 
         equal(
           :expected => 3,
-          :actual   => suite.tests.size,
-          :message  => "number of defined tests"
+          :actual   => suite.assertions.size,
+          :message  => "number of defined assertions"
         ) &&
         equal_unordered(
           :expected => expected_descriptions,
@@ -119,31 +119,31 @@ Test.define "Test", :requires => 'test/debug' do
     suite "#description" do
       assert "A suite should have a description" do
         description = "The suite description"
-        suite       = ::Test::Suite.new(description)
+        suite       = ::BareTest::Suite.new(description)
         equal :expected => description, :actual => suite.description, :message => 'suite description'
       end
     end
 
     suite "#parent" do
       assert "A suite can have a parent suite" do
-        parent = ::Test::Suite.new
-        suite  = ::Test::Suite.new("", parent)
+        parent = ::BareTest::Suite.new
+        suite  = ::BareTest::Suite.new("", parent)
         same :expected => suite.parent, :actual => parent, :message => "suite's parent"
       end
     end
 
     suite "#ancestors" do
       assert "A suite can have ancestors" do
-        grand_parent = ::Test::Suite.new("first")
-        parent       = ::Test::Suite.new("second", grand_parent)
-        suite        = ::Test::Suite.new("third", parent)
+        grand_parent = ::BareTest::Suite.new("first")
+        parent       = ::BareTest::Suite.new("second", grand_parent)
+        suite        = ::BareTest::Suite.new("third", parent)
         equal :expected => suite.ancestors, :actual => [suite, parent, grand_parent], :message => "suite's ancestors"
       end
     end
 
     suite "#suite" do
       assert "Should add new suites to a suite." do
-        suite = ::Test::Suite.new
+        suite = ::BareTest::Suite.new
         equal(
           :expected => 0,
           :actual   => suite.suites.size,
@@ -166,15 +166,15 @@ Test.define "Test", :requires => 'test/debug' do
 
         equal_unordered(
           :expected => ['a', 'b'],
-          :actual   => suite.suites.map { |child| child.description },
+          :actual   => suite.suites.map { |description, child| description },
           :message  => "the descriptions"
         )
       end
 
       assert "Added suites should have the receiving suite as parent." do
-        parent = ::Test::Suite.new
+        parent = ::BareTest::Suite.new
         parent.suite "a"
-        child  = parent.suites.first
+        child  = parent.suites.first.last
 
         same(
           :expected => parent,
@@ -186,12 +186,12 @@ Test.define "Test", :requires => 'test/debug' do
 
     suite "#setup" do
       assert "Called with a block it should add a new setup block." do
-        suite  = ::Test::Suite.new
+        suite  = ::BareTest::Suite.new
         block  = proc {}
-        before = suite.setup.dup
+        before = suite.first_component_variant.dup
 
         suite.setup(&block)
-        after  = suite.setup.dup
+        after  = suite.first_component_variant.dup
 
         equal(
           :expected => 1,
@@ -199,7 +199,7 @@ Test.define "Test", :requires => 'test/debug' do
           :message  => "number of new setup blocks after adding one"
         ) &&
         same(
-          :expected => (after-before).first,
+          :expected => (after-before).first.block,
           :actual   => block,
           :message  => "the new block"
         )
@@ -209,7 +209,7 @@ Test.define "Test", :requires => 'test/debug' do
 
     suite "#teardown" do
       assert "Called with a block it should add a new teardown block." do
-        suite  = ::Test::Suite.new
+        suite  = ::BareTest::Suite.new
         block  = proc {}
         before = suite.teardown.dup
 
@@ -231,38 +231,38 @@ Test.define "Test", :requires => 'test/debug' do
 
     suite "#assert" do
       assert "Should add new assertions to a suite." do
-        suite = ::Test::Suite.new
+        suite = ::BareTest::Suite.new
         equal(
           :expected => 0,
-          :actual   => suite.tests.size,
-          :message  => "number of defined tests before adding any"
+          :actual   => suite.assertions.size,
+          :message  => "number of defined assertions before adding any"
         )
 
         suite.assert "a"
         equal(
           :expected => 1,
-          :actual   => suite.tests.size,
-          :message  => "number of defined tests after adding one"
+          :actual   => suite.assertions.size,
+          :message  => "number of defined assertions after adding one"
         )
 
         suite.assert "b"
         equal(
           :expected => 2,
-          :actual   => suite.tests.size,
-          :message  => "number of defined tests after adding two"
+          :actual   => suite.assertions.size,
+          :message  => "number of defined assertions after adding two"
         )
 
         equal_unordered(
           :expected => ['a', 'b'],
-          :actual   => suite.tests.map { |child| child.description },
+          :actual   => suite.assertions.map { |child| child.description },
           :message  => "the descriptions"
         )
       end
 
-      assert "Added tests should have the receiving suite as suite." do
-        suite     = ::Test::Suite.new
+      assert "Added assertions should have the receiving suite as suite." do
+        suite     = ::BareTest::Suite.new
         suite.assert "a"
-        assertion = suite.tests.first
+        assertion = suite.assertions.first
 
         same(
           :expected => suite,
@@ -271,5 +271,28 @@ Test.define "Test", :requires => 'test/debug' do
         )
       end
     end
+
+    suite "#to_s" do
+      assert "Suite should have a to_s which contains the classname and the description" do
+        description  = "the description"
+        suite        = ::BareTest::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          = ::BareTest::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