baretest 0.1.0

data/test/lib/test/run.rb

@@ -0,0 +1,235 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+Test.define "Test" 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)
+      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
+      end
+
+      assert "Should accept an option ':format'" do
+        raises_nothing do ::Test::Run.new(::Test::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)
+      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)
+      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)
+
+        same(suite, run.suite)
+      end
+    end
+
+    suite "#inits" do
+      setup do
+        Test.extender.clear # avoid interference
+        @executed    = []
+        executed     = @executed # for closure
+        @init_blocks = [
+          proc { executed << :block1 },
+          proc { executed << :block2 }
+        ]
+        init_blocks  = @init_blocks # for closure
+        @extender    = Module.new do |m|
+          (class <<m;self;end).send(:define_method, :extended) do |by|
+            init_blocks.each { |init_block|
+              by.init(&init_block)
+            }
+          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
+      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')
+        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')
+        equal([:block1, :block2], @executed)
+      end
+    end
+
+    suite "#run_all" do
+      assert "Invokes #run_suite with the Run instance's toplevel suite" do
+        invoked_suites = []
+        extender       = Module.new do |m|
+          define_method :run_suite do |suite|
+            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')
+        run.run_all
+
+        equal([toplevel_suite], invoked_suites)
+      end
+    end
+
+    suite "#run_suite" do
+      assert "Invokes #run_suite with every suite in the given suite" do
+        invoked_suites = []
+        extender       = Module.new do |m|
+          define_method :run_suite do |suite|
+            invoked_suites << suite
+            super(suite)
+          end
+        end
+        suites = [
+          ::Test::Suite.new,
+          ::Test::Suite.new
+        ]
+        toplevel_suite = ::Test::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')
+        run.run_suite(toplevel_suite)
+
+        equal_unordered(suites, 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|
+            invoked_tests << test
+          end
+        end
+        toplevel_suite = ::Test::Suite.new
+        assertions     = [
+          ::Test::Assertion.new(toplevel_suite, "assertion1"),
+          ::Test::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')
+        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)
+
+        count_before = run.count[:suite]
+        run.run_suite(toplevel_suite)
+        count_after = run.count[:suite]
+
+        equal(count_before+1, count_after)
+      end
+    end
+
+    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)
+
+        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)
+        count_before = run.count[:test]
+        run.run_test(assertion)
+        count_after = run.count[:test]
+
+        equal(count_before+1, count_after)
+      end
+
+      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)
+          count_before = run.count[:success]
+          run.run_test(assertion)
+          count_after = run.count[:success]
+
+          equal(count_before+1, count_after)
+        end
+      end
+
+      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)
+          count_before = run.count[:pending]
+          run.run_test(assertion)
+          count_after = run.count[:pending]
+
+          equal(count_before+1, count_after)
+        end
+      end
+
+      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)
+          count_before = run.count[:skipped]
+          run.run_test(assertion)
+          count_after = run.count[:skipped]
+
+          equal(count_before+1, count_after)
+        end
+      end
+
+      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)
+          count_before = run.count[:failure]
+          run.run_test(assertion)
+          count_after = run.count[:failure]
+
+          equal(count_before+1, count_after)
+        end
+      end
+
+      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)
+          count_before = run.count[:error]
+          run.run_test(assertion)
+          count_after = run.count[:error]
+
+          equal(count_before+1, count_after)
+        end
+      end
+    end
+  end
+end

data/test/lib/test/suite.rb

@@ -0,0 +1,275 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+Test.define "Test", :requires => 'test/debug' 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) }
+      end
+
+      assert "Should require a single file listed in :requires option." do
+        a = self # ruby1.9 fix, no longer yields self with instance_eval
+        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)
+        Kernel.send(:define_method, :require, original_require)
+
+        touched file
+      end
+
+      assert "Should require all files listed in :requires option." do
+        a = self # ruby1.9 fix, no longer yields self with instance_eval
+        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)
+        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
+      end
+
+      assert "Should return a ::Test::Suite instance without a block." do
+        ::Test::Suite.create.class == ::Test::Skipped::Suite
+      end
+
+      assert "Should return a ::Test::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')
+        Kernel.send(:define_method, :require, original_require)
+
+        return_value.class == ::Test::Skipped::Suite
+      end
+    end
+
+    suite "::new" do
+      assert "Should return a ::Test::Suite instance" do
+        ::Test::Suite.new(nil, nil).class == ::Test::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) }
+      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
+          expected_descriptions.each { |desc|
+            suite desc
+          }
+        end
+        actual_descriptions = suite.suites.map { |child| child.description }
+
+        equal(
+          :expected => 3,
+          :actual   => suite.suites.size,
+          :message  => "number of defined suites"
+        ) &&
+        equal_unordered(
+          :expected => expected_descriptions,
+          :actual   => actual_descriptions,
+          :message  => "the descriptions"
+        )
+      end
+    end
+
+    suite "#tests" do
+      assert "Should return all the suites defined in the block." do
+        expected_descriptions = %w[a b c]
+        suite = ::Test::Suite.new do
+          expected_descriptions.each { |desc|
+            assert desc
+          }
+        end
+        actual_descriptions = suite.tests.map { |child| child.description }
+
+        equal(
+          :expected => 3,
+          :actual   => suite.tests.size,
+          :message  => "number of defined tests"
+        ) &&
+        equal_unordered(
+          :expected => expected_descriptions,
+          :actual   => actual_descriptions,
+          :message  => "the descriptions"
+        )
+      end
+    end
+
+    suite "#description" do
+      assert "A suite should have a description" do
+        description = "The suite description"
+        suite       = ::Test::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)
+        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)
+        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
+        equal(
+          :expected => 0,
+          :actual   => suite.suites.size,
+          :message  => "number of defined suites before adding any"
+        )
+
+        suite.suite "a"
+        equal(
+          :expected => 1,
+          :actual   => suite.suites.size,
+          :message  => "number of defined suites after adding one"
+        )
+
+        suite.suite "b"
+        equal(
+          :expected => 2,
+          :actual   => suite.suites.size,
+          :message  => "number of defined suites after adding two"
+        )
+
+        equal_unordered(
+          :expected => ['a', 'b'],
+          :actual   => suite.suites.map { |child| child.description },
+          :message  => "the descriptions"
+        )
+      end
+
+      assert "Added suites should have the receiving suite as parent." do
+        parent = ::Test::Suite.new
+        parent.suite "a"
+        child  = parent.suites.first
+
+        same(
+          :expected => parent,
+          :actual   => child.parent,
+          :message  => "the parent suite"
+        )
+      end
+    end
+
+    suite "#setup" do
+      assert "Called with a block it should add a new setup block." do
+        suite  = ::Test::Suite.new
+        block  = proc {}
+        before = suite.setup.dup
+
+        suite.setup(&block)
+        after  = suite.setup.dup
+
+        equal(
+          :expected => 1,
+          :actual   => after.size-before.size,
+          :message  => "number of new setup blocks after adding one"
+        ) &&
+        same(
+          :expected => (after-before).first,
+          :actual   => block,
+          :message  => "the new block"
+        )
+
+      end
+    end
+
+    suite "#teardown" do
+      assert "Called with a block it should add a new teardown block." do
+        suite  = ::Test::Suite.new
+        block  = proc {}
+        before = suite.teardown.dup
+
+        suite.teardown(&block)
+        after  = suite.teardown.dup
+
+        equal(
+          :expected => 1,
+          :actual   => after.size-before.size,
+          :message  => "number of new teardown blocks after adding one"
+        ) &&
+        same(
+          :expected => (after-before).first,
+          :actual   => block,
+          :message  => "the new block"
+        )
+      end
+    end
+
+    suite "#assert" do
+      assert "Should add new assertions to a suite." do
+        suite = ::Test::Suite.new
+        equal(
+          :expected => 0,
+          :actual   => suite.tests.size,
+          :message  => "number of defined tests before adding any"
+        )
+
+        suite.assert "a"
+        equal(
+          :expected => 1,
+          :actual   => suite.tests.size,
+          :message  => "number of defined tests after adding one"
+        )
+
+        suite.assert "b"
+        equal(
+          :expected => 2,
+          :actual   => suite.tests.size,
+          :message  => "number of defined tests after adding two"
+        )
+
+        equal_unordered(
+          :expected => ['a', 'b'],
+          :actual   => suite.tests.map { |child| child.description },
+          :message  => "the descriptions"
+        )
+      end
+
+      assert "Added tests should have the receiving suite as suite." do
+        suite     = ::Test::Suite.new
+        suite.assert "a"
+        assertion = suite.tests.first
+
+        same(
+          :expected => suite,
+          :actual   => assertion.suite,
+          :message  => "the suite"
+        )
+      end
+    end
+  end
+end