dtest 0.0.1

data/lib/dtest/report.rb

@@ -0,0 +1,121 @@
+
+module DTest
+  class Report
+    private
+    TAG_BASE = [
+      'Global', 'TestCase', 'Test', 'RUN', 'OK', 'FAIL',
+      'PASSED', 'FAILED', 'TESTED', 'UNTEST',
+    ]
+    TAG_S = TAG_BASE.map {|t| " #{t} "}
+    MAX_LEN = TAG_S.map {|s| s.size}.max
+
+    TAG_MAP = Hash[[TAG_BASE.map {|t| t.downcase.to_sym}, TAG_S].transpose].merge({
+      :line => '-' * MAX_LEN,
+      :empty => ''
+    })
+
+    TAGS_COLOR = {
+      :global => :blue,
+      :testcase => :blue,
+      :test => :blue,
+
+      :run => :yellow,
+      :fail => :red,
+      :ok => :green,
+
+      :passed => :green,
+      :failed => :green,
+      :tested => :green,
+      :untest => :green,
+    }
+
+    # symbol to string
+    def self.tag_s(tag)
+      if TAG_MAP.include?(tag)
+        text = TAG_MAP[tag]
+      else
+        text = tag.to_s
+      end
+    end
+
+    def self.colored_tag(tag)
+      text = tag_s(tag)
+
+      if TAGS_COLOR.include?(tag)
+        send(TAGS_COLOR[tag], text)
+      else
+        text
+      end
+    end
+
+    def self.space(size)
+      if size > 0
+        ' ' * size
+      else
+        ''
+      end
+    end
+
+    def self.s_center(tag)
+      len = MAX_LEN - tag_s(tag).size
+      left = len / 2
+      right = len / 2 + (len.odd? ? 1 : 0)
+      space(left) + colored_tag(tag) + space(right)
+    end
+
+    def self.s_left(tag)
+      colored_tag(tag) + space(MAX_LEN - tag_s(tag).size)
+    end
+
+    def self.s_right(tag)
+      space(MAX_LEN - tag_s(tag).size) + colored_tag(tag)
+    end
+
+    def self.colorize(text, code)
+      if @color_enabled
+        "#{code}#{text}\e[0m"
+      else
+        text
+      end
+    end
+
+    def self.red(text)
+      colorize(text, "\e[31m")
+    end
+
+    def self.green(text)
+      colorize(text, "\e[32m")
+    end
+
+    def self.yellow(text)
+      colorize(text, "\e[33m")
+    end
+
+    def self.blue(text)
+      colorize(text, "\e[34m")
+    end
+
+    public
+    def self.color_enabled=(t)
+      @color_enabled = t
+    end
+
+    def self.split(count = 30)
+      puts ''
+      puts '-' * count
+    end
+
+    def self.tag(s, text = '')
+      puts "[#{s_center(s)}] #{text}"
+    end
+
+    def self.left(s, text = '')
+      puts "[#{s_left(s)}] #{text}"
+    end
+
+    def self.right(s, text = '')
+      puts "[#{s_right(s)}] #{text}"
+    end
+
+  end # class Report
+end # module DTest

data/lib/dtest/result.rb

@@ -0,0 +1,189 @@
+require 'dtest/failure'
+
+module DTest
+
+  module Test
+    class Failure
+      def initialize
+        @failure = []
+      end
+
+      def <<(s)
+        @failure << s
+      end
+
+      def empty?
+        @failure.empty?
+      end
+
+      def failure
+        @failure
+      end
+    end
+
+    # before/after result
+    module BAResult
+    attr_accessor :before_failure, :after_failure
+
+      def initialize
+        super
+        @before_failure = Failure.new
+        @after_failure = Failure.new
+      end
+
+      def ba_empty?
+        @before_failure.empty? && @after_failure.empty?
+      end
+    end  #module BAResult
+
+    class FailureMessage
+      attr_accessor :parent, :name
+      attr_accessor :file, :line, :error_line
+
+      def initialize(parent, name, message, backtrace)
+        @parent = parent
+        @nane = name
+        @message = message
+
+        @file, @line, @error_line = DTest::failure_line(backtrace)
+      end
+
+      def location
+        if file && line
+          "#{file}:#{line}\n"
+        else
+          ""
+        end
+      end
+
+      def all
+        location + @message
+      end
+
+      def print
+        #str += "[#{parent}]" if parent
+        #str += "  '#{name}'\n" if name
+        str = @message
+        str += "  Failure/Error: #{error_line}\n" if error_line
+        str += "  # #{file}:#{line}\n" if file && line
+        puts "#{str}\n"
+      end
+    end  # FailureMessage
+
+
+    class Result < Failure
+      include Stopwatch
+      include BAResult
+
+      PASS = 'Pass'
+      FAIL = 'Fail'
+      UNTEST = 'Untested'
+
+      attr_accessor :name, :result
+
+      def initialize(name)
+        super()
+        @name = name
+        @result = FAIL
+      end
+    end # class Result
+
+    class CaseResult
+      include Stopwatch
+      include BAResult
+
+      attr_accessor :name
+      attr_accessor :result
+      attr_accessor :passed, :failed, :executed, :untested
+
+      def initialize(name)
+        super()
+        @name = name
+        @passed = 0
+        @failed = 0
+        @executed = 0
+        @untested = 0
+        # list of Result
+        @result = []
+      end
+
+      def add(result)
+        @result << result
+      end
+    end # class CaseResult
+
+    class GlobalResult
+      include Stopwatch
+      include BAResult
+
+      attr_accessor :result
+
+      def initialize(testcases)
+        super()
+        @result = []
+        @test_size = testcases.inject(0) { |sum, t| sum += t.test.size}
+      end
+
+      def add(res)
+        @result << res
+      end
+
+      def passed
+        @passed = result.inject(0) {|sum, r| sum += r.passed} unless @passed
+        @passed
+      end
+
+      def failed
+        @failed ||= result.inject(0) {|sum, r| sum += r.failed}
+      end
+
+
+      def executed
+        @executed ||= result.inject(0) {|sum, r| sum += r.executed}
+      end
+
+      def untested
+        @untested ||= @test_size - executed
+      end
+
+      def outputxml(output_path)
+        doc = REXML::Document.new
+        root = doc.add_element('testsuites', {
+          'name' => 'Global',
+          'tests' => executed,
+          'failures' => failed,
+          'errors' => 0,
+          'time' => elapsed,
+        })
+
+        result.each do |result|
+          suite = root.add_element('testsuite', {
+            'name' => result.name,
+            'tests' => result.executed,
+            'failures' => result.failed,
+            'errors' => 0,
+            'time' => result.elapsed,
+          })
+
+          result.result.each do |t|
+            test = suite.add_element('testcase', {
+              'name' => t.name,
+              'status' => 'run',
+              'classname' => result.name,
+              'time' => t.elapsed,
+            })
+            t.failure.each do |msg|
+              failure = test.add_element('failure', {
+                'type' => '',
+              })
+              failure.text = REXML::CData.new(msg.all)
+            end
+          end
+        end
+
+        doc.write(REXML::Output.new(File.new(output_path, 'w+'), REXML::Encoding::UTF_8))
+      end
+    end # class GlobalResult
+
+  end # module Test
+end # module DTest

data/lib/dtest/runner.rb

@@ -0,0 +1,22 @@
+
+
+require 'dtest/core'
+require 'dtest/progress'
+
+module DTest
+  class Runner
+    def self.run(files)
+      files.each do |file|
+        load file
+      end
+
+      test = Test::Manager::instance.cases
+      Global::Manager::instance.harness.start(test)
+    end
+
+    def self.report(gresult)
+      Progress.print_result(gresult)
+    end
+
+  end # class Runner
+end # module DTest

data/lib/dtest/test.rb

@@ -0,0 +1,212 @@
+
+require 'dtest/progress'
+
+module DTest
+  module Test
+    class Case
+      include Hook
+
+      attr_accessor :name
+      attr_accessor :beforeCase, :afterCase
+      attr_accessor :before, :after
+      attr_accessor :test
+
+      def initialize(name, beforeCase, afterCase, before, after, test)
+        @name = name
+        @beforeCase = beforeCase
+        @afterCase = afterCase
+        @before = before
+        @after = after
+        @test = test
+        @defined_values = Object.new
+      end
+
+      private
+      def execute_after_case(list, context)
+        begin
+          exec(list, context)
+        rescue AbortTest, AbortTestCase
+          # にぎりつぶす
+        end
+      end
+
+      # execute before/after
+      def execute_after(list, context)
+        begin
+          exec(list, context)
+        rescue AbortTest
+          # にぎりつぶす
+        end
+      end
+
+      public
+      def execute(global_result)
+        # TestCase result
+        caseresult = CaseResult.new(@name)
+        global_result.add(caseresult)
+
+        # set result
+        @beforeCase.each {|b| b.result = caseresult.before_failure }
+        @afterCase.each {|b| b.result = caseresult.after_failure }
+
+        Progress.setUpTestCase(name, @test.size)
+          executed = 0
+          passed = 0
+          context = Context.new(@defined_values)
+
+          begin
+            caseresult.timer {
+              # execute beforeCase
+              exec(@beforeCase, context)
+
+              # execute each test
+              @test.each do |test|
+                executed += 1
+                result = Result.new(test.name)
+                caseresult.add(result)
+                execute_test(result, test)
+                passed += 1 if result.result == Result::PASS
+              end
+            } # Stopwatch::timer
+          rescue AbortTestCase
+            # にぎりつぶす
+          ensure
+            # report
+            caseresult.passed = passed
+            caseresult.failed = executed - passed
+            caseresult.executed = executed
+            caseresult.untested = @test.size - executed
+
+            # execute afterCase
+            begin
+              execute_after_case(@afterCase, context)
+            ensure
+              # report testcase finished
+              Progress.tearDownTestCase(name, executed, caseresult.elapsed)
+            end
+          end
+      end
+
+      def execute_test(result, test)
+        Progress.test(@name, test.name)
+
+        context = Context.new(@defined_values)
+
+        # set result
+        @before.each {|b| b.result = result.before_failure }
+        @after.each {|b| b.result = result.after_failure }
+
+        begin
+          # execute before blocks
+          exec(@before, context)
+
+          # exeucte test
+          result.timer {
+            test.result = result
+            test.call(context, name)
+          }
+        rescue AbortTest
+          # にぎりつぶす
+          #   次のテストを実行する
+        rescue AbortTestCase, AbortGlobal => e
+          # スルー
+          raise e
+        rescue StandardError, Exception => e
+          # にぎりつぶす
+        ensure
+          begin
+            execute_after(@after, context)
+          ensure
+            if result.failure.empty? && result.ba_empty?
+              result.result = Result::PASS
+              Progress.test_success(@name, test.name)
+            else
+              Progress.test_fail(@name, test.name)
+            end
+          end
+        end
+      end
+    end # class Case
+
+    class Manager
+      include Singleton
+      include Hook
+
+      attr_accessor :cases
+
+      def initialize
+        clear
+      end
+
+      def clear
+        remove_instance_var
+        flush
+        @cases = []
+      end
+
+      def flush
+        @beforeCase = []
+        @afterCase = []
+        @before = []
+        @after = []
+        @test = []
+      end
+
+      def beforeCase(option = {}, &block)
+        @beforeCase << Block.new("beforeCase", option, &block)
+      end
+
+      def afterCase(option = {}, &block)
+        @afterCase << Block.new("afterCase", option, &block)
+      end
+
+      # before test
+      def before(option = {}, &block)
+        @before << Block.new("before", option, &block)
+      end
+
+      # after test
+      def after(option = {}, &block)
+        @after << Block.new("after", option, &block)
+      end
+
+      # return product or args for value-parameterized test
+      def combine(*args)
+        if args.all? {|x| x.is_a? Array}
+          para = args.shift
+          args.each do |x|
+            para = para.product(x)
+          end
+          para.map {|x| x.flatten(1)}
+        else
+          raise ArgumentError, 'All arguments must be Array'
+        end
+      end
+
+      def test(name, option = {}, &block)
+        if option && option[:params]
+          # value-parameterized test
+          params = option[:params]
+          count = 0
+          params.each do |param|
+            test = Block.new("#{name}/#{count}", option, &block)
+            test.parameter = param
+            @test << test
+            count += 1
+          end
+        else
+          # normal test
+          @test << Block.new(name, option, &block)
+        end
+      end
+
+      def add(name)
+        (@beforeCase + @afterCase + @before + @after + @test).each do |block|
+          block.parent = name
+        end
+        @cases << Case.new(name, @beforeCase, @afterCase, @before, @after, @test)
+        flush
+      end
+    end # class Manager
+  end # module Test
+end # module DTest