dtest 0.0.1

data/lib/dtest/core.rb

@@ -0,0 +1,257 @@
+# -*- coding: utf-8 -*-
+
+require 'singleton'
+require 'time'
+require 'rexml/document'
+require 'rexml/cdata'
+
+require 'dtest/failure'
+require 'dtest/util'
+
+require 'dtest/result'
+require 'dtest/test'
+require 'dtest/global'
+
+
+module DTest
+
+  class Abort < Exception
+  end
+
+  class AbortTest < Abort
+    def to_s
+      "AbortTest #{super}"
+    end
+  end
+
+  class AbortTestCase < Abort
+    def to_s
+      "AbortTestCase #{super}"
+    end
+  end
+
+  class AbortGlobal < Abort
+    def to_s
+      "AbortGlobal #{super}"
+    end
+  end
+
+  class Context
+    def initialize(let = nil)
+      # テスト記述側（ブロック）から__stateが参照されないのが前提
+      @__state = {:let => let}
+    end
+
+    def call(state, block)
+      @__state = @__state.merge(state)
+      begin
+        instance_eval(&block)
+      rescue AbortTest, AbortTestCase, AbortGlobal => e
+        # スルー
+        raise e
+      rescue StandardError, Exception => e
+        # ブロック内の例外はabortとして処理する　
+        catch_exception(e)
+        abort_assert
+      end
+    end
+
+    def set(name, val)
+      return if @__state[:let] == nil
+
+      # set variable
+      @__state[:let].instance_variable_set("@#{name}", val)
+      # define getter method
+      @__state[:let].instance_eval <<-EOS
+        def #{name}
+          @#{name}
+        end
+      EOS
+    end
+
+    # :let value getter
+    def method_missing(name, *args, &block)
+      if @__state[:let] && @__state[:let].public_methods.map(&:to_sym).include?(name)
+        # getter value
+        @__state[:let].send(name)
+      else
+        super
+      end
+    end
+
+    # value-parameterized test parameters
+    def param
+      @__state[:parameter]
+    end
+
+    # abort type when assertion failed
+    def assert_failure?
+      @__state[:option][:assert_abort]
+    end
+
+    public
+    # expect/assert
+    def expect_true(condition, message = nil)
+      failed_true(message) unless condition
+    end
+
+    def expect_false(condition, message = nil)
+      failed_false(message) if condition
+    end
+
+    def expect_equal(expected, actual, message = nil)
+      failed_equal(expected, actual, message) unless expected == actual
+    end
+
+    def expect_not_equal(expected, actual, message = nil)
+      failed_equal(expected, actual, message) if expected == actual
+    end
+
+    def assert_true(condition, message = nil)
+      unless condition
+        failed_true(message)
+        abort_assert
+      end
+    end
+
+    def assert_false(condition, message = nil)
+      if condition
+        failed_false(message)
+        abort_assert
+      end
+    end
+
+    def assert_equal(expected, actual, message = nil)
+      unless expected == actual
+        failed_equal(expected, actual, message)
+        abort_assert
+      end
+    end
+
+    def assert_not_equal(expected, actual, message = nil)
+      if expected == actual
+        failed_equal(expected, actual, message)
+        abort_assert
+      end
+    end
+
+    def assert_error(*errors, &block)
+      begin
+        block.call
+      rescue *errors => actual_error
+        raised_expected_error = true
+      rescue RuntimeError, Exception => actual_error
+        raised_expected_error = false
+      else
+        str = "exception expected but none was thrown\n"
+        failed(str)
+        return
+      end
+
+      unless raised_expected_error
+        str = "exception expected #{errors.to_s} but #{actual_error.inspect}\n"
+        failed(str)
+      end
+    end
+
+    # abort
+    def abort_if(condition, message = nil)
+      str = "Abort"
+      str += ": #{message}\n" if message
+      failed(str)
+      raise AbortTest.new(str) if condition
+    end
+
+    def abort_case_if(condition, message = nil)
+      str = "Abort TestCase"
+      str += ": #{message}\n" if message
+      failed(str)
+      raise AbortTestCase.new(str) if condition
+    end
+
+    def abort_global_if(condition, message = nil)
+      str = "Abort global"
+      str += ": #{message}\n" if message
+      failed(str)
+      raise AbortGlobal.new(str) if condition
+    end
+
+    private #internal methods
+    def failed_equal(expected, actual, message = nil)
+      str = <<END
+  expected: #{expected.inspect}
+       got: #{actual.inspect}
+END
+      str += "#{message}\n" if message
+      failed(str, 3)
+    end
+
+    def failed_true(message = nil)
+      str = "condition must be true\n"
+      str += "#{message}\n" if message
+      failed(str, 3)
+    end
+
+    def failed_false(message = nil)
+      str = "condition must be false\n"
+      str += "#{message}\n" if message
+      failed(str, 3)
+    end
+
+    def catch_exception(e)
+      str = "Exception #{e.inspect}\n"
+      add_failure(str, e.backtrace.first)
+    end
+
+    def add_failure(error, backtrace)
+      if @__state[:result]
+        @__state[:result] << (Test::FailureMessage.new(@__state[:parent], @__state[:name], error, backtrace))
+      end
+    end
+
+    # push failure message
+    def failed(error, level = 2)
+      add_failure(error, caller(level).first)
+    end
+
+    def abort_assert
+      case assert_failure?
+      when :global
+        raise AbortGlobal.new
+      when :testcase
+        raise AbortTestCase.new
+      else
+        raise AbortTest.new
+      end
+    end
+  end # class Context
+
+
+  class Block
+    attr_reader :name
+    attr_accessor :parent, :result, :parameter
+
+    def initialize(name, option, &block)
+      @name = name
+      @parent = nil
+      @option = option
+      @block = block
+      @result = nil # caller result object
+      @parameter = nil
+    end
+
+    def call(context, name = nil)
+      @parent = name if name
+      context.call({
+        :parent => @parent,
+        :name => @name,
+        :option => @option,
+        :result => @result,
+        :parameter => @parameter,
+      }, @block)
+    end
+
+  end # class Context
+
+end # module DTest
+

data/lib/dtest/dsl.rb

@@ -0,0 +1,19 @@
+
+require 'dtest/core'
+
+module DTest
+  module DSL
+    def TestCase(name, options = {}, &block)
+      manager = Test::Manager::instance
+      manager.instance_eval(&block)
+      manager.add(name)
+    end
+
+    def GlobalHarness(&block)
+      manager = Global::Manager::instance
+      manager.instance_eval(&block)
+    end
+  end # module DSL
+end # module DTest
+
+include DTest::DSL

data/lib/dtest/failure.rb

@@ -0,0 +1,27 @@
+
+module DTest
+  def self.parse_caller(at)
+    if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+      file = $1
+      line = $2.to_i
+      method = $3
+      [file, line, method]
+    else
+      nil
+    end
+  end
+
+  def self.failure_line(backtrace)
+    file, line, method = parse_caller(backtrace)
+    if file && line && File.exists?(file)
+      [file, line, File.readlines(file)[line - 1].strip]
+    else
+      [file, line, "Unable to find #{file} to read failed line"]
+    end
+  end
+
+  def self.failure_caller(level)
+    failure_line(caller(level).first)
+  end
+end # DTest
+

data/lib/dtest/global.rb

@@ -0,0 +1,91 @@
+
+module DTest
+  module Global
+    class Harness
+      include Hook
+
+      attr_accessor :global
+      attr_accessor :before, :after
+
+      def initialize
+        @before = []
+        @after = []
+      end
+
+      def execute_after(list, context)
+        begin
+          exec(list, context)
+        rescue StandardError, Exception => e
+          # にぎりつぶす
+        end
+      end
+
+      def start(testcases)
+        # Progress
+        context = Context.new
+        Progress.setUpGlobal(testcases)
+
+        global_result = Test::GlobalResult.new(testcases)
+
+        @before.each {|b| b.result = global_result.before_failure }
+        @after.each {|b| b.result = global_result.after_failure }
+
+        global_result.timer {
+          begin
+            # execute before
+            exec(@before, context)
+
+            # execute cases
+            testcases.each do |testcase|
+              execute_testcase(global_result, testcase)
+            end
+          rescue AbortGlobal => e
+            # finish
+          rescue StandardError, Exception => e
+            # Blockでエラー処理しているので、にぎりつぶす
+          ensure
+            execute_after(@after, context)
+            Progress.tearDownGlobal
+          end
+        }
+
+        global_result
+      end
+
+      def execute_testcase(global_result, testcase)
+        begin
+          # execute TestCases
+          testcase.execute(global_result)
+        rescue AbortTest, AbortTestCase => e
+          # にぎりつぶす
+        end
+      end
+    end # class Harness
+
+    class Manager
+      include Singleton
+      attr_accessor :harness
+
+      def initialize
+        clear
+      end
+
+      def clear
+        remove_instance_var
+        @harness = Harness.new
+      end
+
+      def before(option = {}, &block)
+        b = Block.new("before", option, &block)
+        b.parent = 'Global'
+        @harness.before << b
+      end
+
+      def after(option = {}, &block)
+        b = Block.new("after", option, &block)
+        b.parent = 'Global'
+        @harness.after << b
+      end
+    end # class Manager
+  end # module Global
+end # module DTest

data/lib/dtest/progress.rb

@@ -0,0 +1,166 @@
+
+require 'dtest/report'
+
+module DTest
+  class Progress
+    def self.test_str(test_size)
+      test_str = test_size > 1 ? 'tests' : 'test'
+      "#{test_size} #{test_str}"
+    end
+
+    def self.case_str(testcase_size)
+      testcase_str = testcase_size > 1 ? 'cases' : 'case'
+      "#{testcase_size} #{testcase_str}"
+    end
+
+    def self.error_str(size)
+      str = 'error'
+      str += 's' if size > 0
+      "#{size} #{str}"
+    end
+
+    def self.setUpGlobal(testcase)
+      test_size = testcase.inject(0) { |sum, t| sum += t.test.size}
+      Report.tag :global, test_str(test_size) + " from " + case_str(testcase.size)
+      Report.tag :global, "Global test environment set-up."
+      puts ''
+    end
+
+    def self.tearDownGlobal
+      Report.tag :global, "Global test environment tear-down."
+    end
+
+    def self.setUpTestCase(name, size)
+      Report.tag :line, test_str(size) + " from #{name}"
+      Report.tag :testcase, "#{name} set-up."
+    end
+
+    def self.tearDownTestCase(name, size, elapsed)
+      Report.tag :testcase, "#{name} tear-down."
+      Report.tag :line, test_str(size) + " executed from #{name} (#{elapsed} seconds)"
+      puts ''
+    end
+
+    def self.test(casename, name)
+      Report.left :run, "#{casename}.#{name}"
+    end
+
+    def self.test_success(casename, name)
+      Report.right :ok, "#{casename}.#{name}"
+    end
+
+    def self.test_fail(casename, name)
+      Report.right :fail, "#{casename}.#{name}"
+    end
+
+    def self.print_result(gresult)
+      #  collect TestCase failures
+      cases = []
+      gresult.result.each do |result|
+        # test
+        test = []
+        result.result.each do |r|
+          unless r.empty? && r.ba_empty?
+            test << r
+          end
+        end
+
+        unless result.ba_empty? && test.empty?
+          cases << {
+            :case => result,
+            :test => test,
+          }
+        end
+      end
+
+      global_failed = !gresult.ba_empty?
+
+      #####################
+      # Output error status
+      split = global_failed || !cases.empty?
+      Report.split if split
+
+      # Report Global
+      if global_failed
+        err = []
+        err << 'before' unless gresult.before_failure.empty?
+        err << 'after' unless gresult.after_failure.empty?
+        Report.tag :global, "Global failure"
+        Report.tag :empty, "  " + err.join(', ')
+      end
+
+      # Report TestCase
+      unless cases.empty?
+        str = cases.inject([]) {|a, s| a << s[:case].name }.join(', ')
+        Report.tag :testcase, "#{case_str(cases.size)}"
+        Report.tag :empty, "  #{str}"
+      end
+
+      # Report test each cases
+      cases.each do |x|
+        c = x[:case]
+        t = x[:test]
+        err = []
+        err << 'beforeCase' unless c.before_failure.empty?
+        err << 'afterCase' unless c.after_failure.empty?
+        err = t.inject(err) {|a, s| a << s.name }
+        Report.tag :test, "#{c.name}:  #{error_str(err.size)}"
+        Report.tag :empty, "  #{err.join(', ')}"
+      end
+
+
+
+      ##################
+      # Output failures
+      Report.split if split
+
+      # Global before/after failure
+      if global_failed
+        # before
+        Report.tag :fail, 'Global.before' unless gresult.before_failure.empty?
+        print_failure(gresult.before_failure)
+
+        # after
+        Report.tag :fail, 'Global.after' unless gresult.after_failure.empty?
+        print_failure(gresult.after_failure)
+      end
+
+      # Report testcase and test failures
+      cases.each do |x|
+        c = x[:case]
+        casename = c.name
+        #Report.tag :testcase, "#{casename}"
+        # testcase before/after
+        Report.tag :fail, "#{casename}.beforeCase" unless c.before_failure.empty?
+        print_failure(c.before_failure)
+        Report.tag :fail, "#{casename}.afterCase" unless c.after_failure.empty?
+        print_failure(c.after_failure)
+
+        # test before/test/after
+        x[:test].each do |t|
+          name = t.name
+          Report.tag :fail, "#{casename}.#{name}.before" unless t.before_failure.empty?
+          print_failure(t.before_failure)
+          Report.tag :fail, "#{casename}.#{name}" unless t.failure.empty?
+          print_failure(t)
+          Report.tag :fail, "#{casename}.#{name}.after" unless t.after_failure.empty?
+          print_failure(t.after_failure)
+        end
+      end
+
+      puts ""
+      puts "Finished in #{gresult.elapsed} seconds"
+      puts "--------------------------------"
+      Report.tag :passed, gresult.passed
+      Report.tag :failed, gresult.failed
+      Report.tag :tested, gresult.executed
+      Report.tag :untest, gresult.untested
+    end
+
+    def self.print_failure(failure)
+      failure.failure.each do |msg|
+        msg.print
+      end
+    end
+  end # class Progress
+end # module DTest