dtest 0.0.1

data/spec/test_assert_spec.rb

@@ -0,0 +1,146 @@
+
+require 'dtest/dsl'
+require 'dtest/runner'
+include DTest
+
+describe Global::Manager, 'test assert' do
+
+  before do
+    $call = []
+  end
+
+  after do
+    Global::Manager.instance.clear
+    Test::Manager.instance.clear
+  end
+
+  it "assert global before" do
+    GlobalHarness do
+      before do
+        assert_equal(1,2)
+      end
+
+      after do
+      end
+    end
+
+    TestCase "test" do
+      test "empty" do
+      end
+    end
+
+    global_report = Runner.run([])
+    global_report.before_failure.failure.size.should == 1
+    global_report.after_failure.failure.size.should == 0
+  end
+
+  it "assert global after" do
+    GlobalHarness do
+      before do
+      end
+
+      after do
+        assert_equal(1 ,2)
+      end
+    end
+    TestCase "test" do
+      test "empty" do
+      end
+    end
+    global_report = Runner.run([])
+    global_report.before_failure.failure.size.should == 0
+    global_report.after_failure.failure.size.should == 1
+  end
+
+  it "assert testcase before/after" do
+    GlobalHarness do
+    end
+    TestCase "test" do
+      beforeCase do
+        assert_equal(1, 2)
+      end
+      afterCase do
+        assert_equal(1, 2)
+      end
+    end
+    global_report = Runner.run([])
+    global_report.result.size.should == 1
+    global_report.result.first.before_failure.failure.size.should == 1
+    global_report.result.first.after_failure.failure.size.should == 1
+  end
+
+
+  it "simple assert test" do
+    GlobalHarness do
+    end
+
+    TestCase "test" do
+      test "assert_equal" do
+        $call << :assert_equal
+        assert_equal(1, 1)
+        $call << :assert_equal
+        assert_equal(1, 2)
+        $call << :assert_equal_not_executed
+      end
+
+      test "assert_not_equal" do
+        $call << :assert_not_equal
+        assert_not_equal(1, 2)
+        $call << :assert_not_equal
+        assert_not_equal(1, 1)
+        $call << :assert_equal_not_executed
+      end
+
+      test "assert_true" do
+        $call << :assert_true
+        assert_true(true)
+        $call << :assert_true
+        assert_true(false)
+        $call << :assert_true_not_executed
+      end
+
+      test "assert_false" do
+        $call << :assert_false
+        assert_false(false)
+        $call << :assert_false
+        assert_false(true)
+        $call << :assert_not_true_not_executed
+      end
+
+
+      test "assert GlobalAbort", :assert_abort => :global do
+        $call << :assert_abort
+        assert_equal(1, 100)
+        $call << :not_executed
+      end
+    end
+
+    TestCase "not executed" do
+      test "not executed" do
+        $call << :not_executed
+      end
+    end
+
+    call = [
+      :assert_equal,
+      :assert_equal,
+
+      :assert_not_equal,
+      :assert_not_equal,
+
+      :assert_true,
+      :assert_true,
+
+      :assert_false,
+      :assert_false,
+
+      :assert_abort,
+    ]
+
+    global_report = Runner.run([])
+    $call.should == call
+  end
+
+
+end
+

data/spec/test_exception_spec.rb

@@ -0,0 +1,303 @@
+require 'dtest/dsl'
+require 'dtest/runner'
+include DTest
+
+describe Global::Manager, 'global before/after exception' do
+  before do
+    $call = []
+  end
+
+  after do
+    Global::Manager.instance.clear
+    Test::Manager.instance.clear
+  end
+
+  it "global_before" do
+
+    GlobalHarness do
+      before do
+        $call << :before
+        raise Exception.new("test_global_before")
+        $call << :not_executed
+      end
+      after do
+        $call << :after
+      end
+    end
+
+    Runner.run([])
+    $call.should == [:before, :after]
+  end
+
+  it "global_after" do
+    GlobalHarness do
+      before do
+        $call << :before
+      end
+      after do
+        $call << :after
+        raise Exception.new("test_global_after")
+        $call << :not_executed
+      end
+    end
+
+    Runner.run([])
+    $call.should == [:before, :after]
+  end
+end
+
+
+describe Global::Manager, 'test before/after exception' do
+  before do
+    $call = []
+    GlobalHarness do
+      before do
+        $call << :beforeGlobal
+      end
+      after do
+        $call << :afterGlobal
+      end
+    end
+  end
+
+  after do
+    Global::Manager.instance.clear
+    Test::Manager.instance.clear
+  end
+
+  it "testcase:beforeCase" do
+    TestCase "testcase1" do
+      beforeCase do
+        $call << :beforeCase
+        raise Exception.new("test_beforeCase")
+        $call << :not_executed
+      end
+
+      afterCase do
+        $call << :afterCase
+      end
+
+      test "test1" do
+        $call << :test_not_executed  # not_executed
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+        :beforeCase,
+        :afterCase,
+      :afterGlobal
+    ]
+  end
+
+  it "testcase:afterCase" do
+    TestCase "testcase1" do
+      beforeCase do
+        $call << :beforeCase
+      end
+
+      afterCase do
+        $call << :afterCase
+        raise Exception.new("test_afterCase")
+        $call << :not_executed
+      end
+
+      test "test1" do
+        $call << :test
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+        :beforeCase,
+        :test,
+        :afterCase,
+      :afterGlobal
+    ]
+  end
+
+  it "test:after" do
+    TestCase "after" do
+      before do
+        $call << :beforeCase
+      end
+
+      after do
+        $call << :afterCase
+        raise Exception.new("test_after")
+        $call << :not_executed
+      end
+
+      test "test1" do
+        $call << :test
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+        :beforeCase,
+        :test,
+        :afterCase,
+      :afterGlobal
+    ]
+  end
+
+  it "test:before" do
+    TestCase "after" do
+      before do
+        $call << :before
+        raise Exception.new("test_before")
+        $call << :not_executed
+      end
+
+      after do
+        $call << :after
+      end
+
+      test "test1" do
+        $call << :test_not_executed  # not_executed
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+        :before,
+        :after,
+      :afterGlobal
+    ]
+  end
+
+end
+
+
+
+describe Global::Manager, 'exception catch' do
+  before do
+    $call = []
+
+    GlobalHarness do
+      before do
+        $call << :beforeGlobal
+      end
+      after do
+        $call << :afterGlobal
+      end
+    end
+  end
+
+  after do
+    Global::Manager.instance.clear
+    Test::Manager.instance.clear
+  end
+
+  it "exception caught" do
+    TestCase "exception_test" do
+      test "test1" do
+        assert_error(IOError) do
+          test = nil
+          tes += "" # NoMethodError
+        end
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+      :afterGlobal
+    ]
+
+  end
+
+  it "exception none was thrown" do
+
+    TestCase "exception_none" do
+      test "test1" do
+        assert_error(Exception) do
+        end
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+      :afterGlobal
+    ]
+
+  end
+
+  it "abort test" do
+    TestCase "testcase1" do
+      test "test1" do
+        $call << :test1
+        raise Exception.new("test1(assert_abort => :testcase)")
+        $call << :not_executed
+      end
+
+      test "test2" do
+        $call << :test2
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+        :test1,
+        :test2,
+      :afterGlobal
+    ]
+  end
+
+  it "abort testcase" do
+    TestCase "testcase1" do
+      test "test1", :assert_abort => :testcase do
+        $call << :test1
+        raise Exception.new("test1(assert_abort => :testcase)")
+      end
+
+      test "test2" do
+        $call << :test2_not_executed
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+        :test1,
+      :afterGlobal
+    ]
+  end
+
+  it "abort global" do
+    TestCase "testcase1" do
+      test "test1", :assert_abort => :global do
+        $call << :test1
+        raise Exception.new("test1(assert_abort => :global)")
+      end
+
+      test "test2" do
+        $call << :test2_not_executed
+      end
+    end
+
+    TestCase "testcase2" do
+      test "test1" do
+        $call << :test1_not_executed
+      end
+    end
+
+    Runner.run([])
+    $call.should == [
+      :beforeGlobal,
+        :test1,
+      :afterGlobal
+    ]
+  end
+
+end
+
+
+

data/spec/test_expect_spec.rb

@@ -0,0 +1,288 @@
+require 'dtest/dsl'
+require 'dtest/runner'
+include DTest
+
+
+describe Global::Manager, 'execpted' do
+  before do
+    $call = []
+  end
+
+  after do
+    Global::Manager.instance.clear
+    Test::Manager.instance.clear
+  end
+
+  it "test expect_true" do
+    GlobalHarness do
+      before do
+        expect_true(false)
+        $call << :beforeGlobal
+      end
+
+      after do
+        expect_true(false)
+        $call << :afterGlobal
+      end
+    end
+
+    TestCase "expect_true" do
+      beforeCase do
+        expect_true(false)
+        $call << :beforeCase
+      end
+
+      afterCase do
+        expect_true(false)
+        $call << :afterCase
+      end
+
+      before do
+        expect_true(false)
+        $call << :before
+      end
+
+      after do
+        expect_true(false)
+        $call << :after
+      end
+
+      test "test1" do
+        expect_true(false)
+        $call << :test1
+        expect_true(false)
+        $call << :test2
+      end
+    end
+
+    call = [
+      :beforeGlobal,
+        :beforeCase,
+          :before,
+            :test1,
+            :test2,
+          :after,
+        :afterCase,
+      :afterGlobal,
+    ]
+
+
+    Runner.run([])
+    $call.should == call
+  end
+
+  it "test expect_equal" do
+    GlobalHarness do
+      before do
+        expect_equal(true, false)
+        $call << :beforeGlobal
+      end
+
+      after do
+        expect_equal(true, false)
+        $call << :afterGlobal
+      end
+    end
+
+    TestCase "expect_equal" do
+      beforeCase do
+        expect_equal(true, false)
+        $call << :beforeCase
+      end
+
+      afterCase do
+        expect_equal(true, false)
+        $call << :afterCase
+      end
+
+      before do
+        expect_equal(true, false)
+        $call << :before
+      end
+
+      after do
+        expect_equal(true, false)
+        $call << :after
+      end
+
+      test "test1" do
+        expect_equal(true, false)
+        $call << :test1
+        expect_equal(true, false)
+        $call << :test2
+      end
+    end
+
+    call = [
+      :beforeGlobal,
+        :beforeCase,
+          :before,
+            :test1,
+            :test2,
+          :after,
+        :afterCase,
+      :afterGlobal,
+    ]
+
+    Runner.run([])
+    $call.should == call
+  end
+
+  it "simple expect test" do
+
+    TestCase "test" do
+      before do
+      end
+
+      after do
+      end
+
+      test "expect_equal" do
+        $call << :expect_equal
+        expect_equal(1, 1)
+        $call << :expect_equal
+        expect_equal(1, 2)
+        $call << :expect_equal
+      end
+
+      test "expect_not_equal" do
+        $call << :expect_not_equal
+        expect_not_equal(1, 2)
+        $call << :expect_not_equal
+        expect_not_equal(1, 1)
+        $call << :expect_not_equal
+      end
+
+      test "expect_true" do
+        $call << :expect_true
+        expect_true(true)
+        $call << :expect_true
+        expect_true(false)
+        $call << :expect_true
+      end
+
+      test "expect_false" do
+        $call << :expect_false
+        expect_false(false)
+        $call << :expect_false
+        expect_false(true)
+        $call << :expect_false
+      end
+
+    end
+
+    TestCase "testcase2" do
+      test "test2" do
+        $call << :test
+      end
+    end
+
+    call = [
+      :expect_equal,
+      :expect_equal,
+      :expect_equal,
+
+      :expect_not_equal,
+      :expect_not_equal,
+      :expect_not_equal,
+
+      :expect_true,
+      :expect_true,
+      :expect_true,
+
+      :expect_false,
+      :expect_false,
+      :expect_false,
+
+      :test,
+    ]
+
+    global_report = Runner.run([])
+    $call.should == call
+  end
+end
+
+
+
+describe Global::Manager, 'expect failure count' do
+  before do
+    GlobalHarness do
+      before do
+      end
+
+      after do
+      end
+    end
+  end
+
+  after do
+    Global::Manager.instance.clear
+    Test::Manager.instance.clear
+  end
+
+  it "fail_before" do
+    TestCase "before" do
+      before do
+        expect_true(false)
+      end
+
+      after do
+      end
+
+      test "test" do
+      end
+
+      test "test" do
+      end
+    end
+    global = Runner.run([])
+    global.result.size.should == 1
+    result = global.result[0].result
+    result.size.should == 2
+    result[0].before_failure.failure.size.should == 1
+    result[1].before_failure.failure.size.should == 1
+    global.passed.should == 0
+    global.failed.should == 2
+  end
+
+  it "fail_after" do
+    TestCase "after" do
+      before do
+      end
+
+      after do
+        expect_true(false)
+      end
+
+      test "test" do
+      end
+      test "test" do
+      end
+    end
+    global = Runner.run([])
+    global.passed.should == 0
+    global.failed.should == 2
+  end
+
+  it "fail_test" do
+    TestCase "after" do
+      before do
+      end
+
+      after do
+      end
+
+      test "test" do
+        expect_true(false)
+      end
+
+      test "test" do
+        expect_true(true)
+      end
+    end
+    global = Runner.run([])
+    global.passed.should == 1
+    global.failed.should == 1
+  end
+end
+