test-unit 2.2.0 → 2.3.0

data/lib/test/unit/autorunner.rb

@@ -83,6 +83,14 @@ module Test
         collector.collect(*auto_runner.to_run)
       end
 
+      # JUST TEST!
+      # register_collector(:xml) do |auto_runner|
+      #   require 'test/unit/collector/xml'
+      #   collector = Collector::XML.new
+      #   collector.filter = auto_runner.filters
+      #   collector.collect(auto_runner.to_run[0])
+      # end
+
       # deprecated
       register_collector(:object_space) do |auto_runner|
         require 'test/unit/collector/objectspace'
@@ -152,13 +160,18 @@ module Test
           o.banner = "Test::Unit automatic runner."
           o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
 
-          o.on
           o.on('-r', '--runner=RUNNER', RUNNERS,
                "Use the given RUNNER.",
                "(" + keyword_display(RUNNERS) + ")") do |r|
             @runner = r
           end
 
+          o.on('--collector=COLLECTOR', COLLECTORS,
+               "Use the given COLLECTOR.",
+               "(" + keyword_display(COLLECTORS) + ")") do |collector|
+            @collector = collector
+          end
+
           if (@standalone)
             o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
               @base = b
@@ -397,3 +410,4 @@ end
 require 'test/unit/runner/console'
 require 'test/unit/runner/emacs'
 require 'test/unit/runner/tap'
+require 'test/unit/runner/xml'

data/lib/test/unit/collector/xml.rb

@@ -0,0 +1,250 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
+# License:: Ruby license.
+
+# just test!!! don't use it yet!!!
+
+require 'test/unit/collector'
+
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module Test
+  module Unit
+    module Collector
+      class XML
+        include Collector
+
+        def collect(xml_log_path)
+          listener = Listener.new
+          File.open(xml_log_path) do |xml_log|
+            parser = REXML::Parsers::StreamParser.new(xml_log, listener)
+            parser.parse
+          end
+          suite = TestSuite.new("tests in #{xml_log_path}")
+          suites = listener.test_suites
+          sort(suites).each {|s| add_suite(suite, s)}
+          suite
+        end
+
+        class Listener
+          include REXML::StreamListener
+
+          attr_reader :test_suites
+          def initialize
+            @ns_stack = [{"xml" => :xml}]
+            @tag_stack = [["", :root]]
+            @text_stack = ['']
+            @state_stack = [:root]
+            @values = {}
+            @test_suites = []
+          end
+
+          def tag_start(name, attributes)
+            @text_stack.push('')
+
+            ns = @ns_stack.last.dup
+            attrs = {}
+            attributes.each do |n, v|
+              if /\Axmlns(?:\z|:)/ =~ n
+                ns[$POSTMATCH] = v
+              else
+                attrs[n] = v
+              end
+            end
+            @ns_stack.push(ns)
+
+            _parent_tag = parent_tag
+            prefix, local = split_name(name)
+            uri = _ns(ns, prefix)
+            @tag_stack.push([uri, local])
+
+            state = next_state(@state_stack.last, uri, local)
+            @state_stack.push(state)
+            case state
+            when :test_suite, :test_case
+              @values = {}
+            when :test
+              @values = {}
+              @n_pass_assertions = 0 if _parent_tag == "start-test"
+            when :backtrace
+              @backtrace = []
+              @values_backup = @values
+              @values = {}
+            end
+          end
+
+          def tag_end(name)
+            state = @state_stack.pop
+            text = @text_stack.pop
+            uri, local = @tag_stack.pop
+            no_action_states = [:root, :stream]
+            case state
+            when *no_action_states
+              # do nothing
+            when :test_suite
+              test_suite_end
+            when :complete_test_case
+              @test_suites.last << @test_case.suite
+            when :test_case
+              test_case_end
+            when :result
+              @result = @values
+            when :test
+              test_end
+            when :pass_assertion
+              @n_pass_assertions += 1
+            when :backtrace
+              @values = @values_backup
+              @values["backtrace"] = @backtrace
+            when :entry
+              file = @values['file']
+              line = @values['line']
+              info = @values['info']
+              @backtrace << "#{file}:#{line}: #{info}"
+              @values = {}
+            else
+              local = normalize_local(local)
+              @values[local] = text
+            end
+            @ns_stack.pop
+          end
+
+          def text(data)
+            @text_stack.last << data
+          end
+
+          private
+          def _ns(ns, prefix)
+            ns.fetch(prefix, "")
+          end
+
+          NAME_SPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
+          def split_name(name)
+            name =~ NAME_SPLIT
+            [$1 || '', $2]
+          end
+
+          STATE_TABLE = {
+            :root => [:stream],
+            :stream => [:ready_test_suite,
+                        :start_test_suite,
+                        :ready_test_case,
+                        :start_test_case,
+                        :start_test,
+                        :pass_assertion,
+                        :test_result,
+                        :complete_test,
+                        :complete_test_case,
+                        :complete_test_suite,
+                        :success],
+            :ready_test_suite => [:n_tests],
+            :start_test_suite => [:test_suite],
+            :ready_test_case => [:test_case,
+                                 :n_tests],
+            :start_test_case => [:test_case],
+            :start_test => [:test],
+            :pass_assertion => [:test],
+            :complete_test => [:test, :success],
+            :complete_test_case => [:test_case,
+                                    :elapsed,
+                                    :success],
+            :complete_test_suite => [:test_suite,
+                                     :success],
+            :test_suite => [:start_time,
+                            :elapsed],
+            :test_case => [:name,
+                           :start_time,
+                           :elapsed],
+            :test => [:name,
+                      :start_time,
+                      :elapsed],
+            :test_result => [:test,
+                             :result],
+            :result => [:test_case,
+                        :test,
+                        :status,
+                        :backtrace,
+                        :detail],
+            :backtrace => [:entry],
+            :entry => [:file,
+                       :line,
+                       :info],
+          }
+          def next_state(current_state, uri, local)
+            local = normalize_local(local)
+            valid_elements = STATE_TABLE[current_state]
+            if valid_elements.nil?
+              raise "unexpected element: #{current_path}"
+            end
+            next_state = local.to_sym
+            unless valid_elements.include?(next_state)
+              raise "unexpected element: #{current_path}"
+            end
+            next_state
+          end
+
+          def current_path
+            locals = @tag_stack.collect do |uri, local|
+              local
+            end
+            ["", *locals].join("/")
+          end
+
+          def normalize_local(local)
+            local.gsub(/-/, "_")
+          end
+
+          def parent_tag
+            @tag_stack.last[1]
+          end
+
+          def test_suite_end
+            return unless parent_tag == "start-test-suite"
+            suite = TestSuite.new
+            ["start_time", "elapsed_time", "n_tests"].each do |key|
+              if @values.has_key?(key)
+                suite.instance_variable_set("@#{key}", @values[key])
+              end
+            end
+            @test_suites << suite
+          end
+
+          def test_case_end
+            return unless parent_tag == "start-test-case"
+            name = @values["name"]
+            @test_case = Class.new(TestCase) do
+              define_method(:name) do
+                name
+              end
+            end
+          end
+
+          def test_end
+            return unless parent_tag == "complete-test"
+            name = @values["name"]
+            n_pass_assertions = @n_pass_assertions
+            result = @result
+            @test_case.module_eval do
+              test
+              define_method(name) do
+                n_pass_assertions.times do
+                  add_assertion
+                end
+                case result["status"]
+                when "omission"
+                  add_omission(Omission.new(name,
+                                            result["backtrace"],
+                                            result["detail"]))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test/unit/data.rb

@@ -0,0 +1,80 @@
+module Test
+  module Unit
+    module Data
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        # TODO: WRITE ME.
+        def data(*arguments, &block)
+          n_arguments = arguments.size
+          case n_arguments
+          when 0
+            data_set = block
+          when 1
+            data_set = arguments[0]
+          when 2
+            data_set = {arguments[0] => arguments[1]}
+          else
+            message= "wrong number arguments(#{n_arguments} for 1..2)"
+            raise ArgumentError, message
+          end
+          current_data = current_attribute(:data)[:value] || []
+          attribute(:data, current_data + [data_set])
+        end
+
+        # TODO: WRITE ME.
+        def load_data(file_name)
+          case file_name
+          when /\.csv/i
+            loader = CSVDataLoader.new(self)
+            loader.load(file_name)
+          else
+            raise ArgumentError, "unsupported file format: <#{file_name}>"
+          end
+        end
+
+        class CSVDataLoader
+          def initialize(test_case)
+            @test_case = test_case
+          end
+
+          def load(file_name)
+            require 'csv'
+            header = nil
+            CSV.foreach(file_name) do |row|
+              if header.nil?
+                header = row
+                next
+              end
+              label = nil
+              data = {}
+              header.each_with_index do |key, i|
+                if key == "label"
+                  label = row[i]
+                else
+                  data[key] = normalize_value(row[i])
+                end
+              end
+              @test_case.data(label, data)
+            end
+          end
+
+          private
+          def normalize_value(value)
+            Integer(value)
+          rescue ArgumentError
+            begin
+              Float(value)
+            rescue ArgumentError
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test/unit/error.rb

@@ -48,13 +48,14 @@ module Test
 
       # Returns a verbose version of the error description.
       def long_display
-        backtrace_display = backtrace.join("\n    ")
+        backtrace_display = location.join("\n    ")
         "#{label}:\n#@test_name:\n#{message}\n    #{backtrace_display}"
       end
 
-      def backtrace
-        filter_backtrace(@exception.backtrace)
+      def location
+        @location ||= filter_backtrace(@exception.backtrace)
       end
+      alias_method :backtrace, :location # Deprecated
 
       # Overridden to return long_display.
       def to_s

data/lib/test/unit/fixture.rb

@@ -5,7 +5,7 @@ module Test
         def included(base)
           base.extend(ClassMethods)
 
-          [:setup, :teardown].each do |fixture|
+          [:setup, :cleanup, :teardown].each do |fixture|
             observer = Proc.new do |test_case, _, _, value, method_name|
               if value.nil?
                 test_case.send("unregister_#{fixture}_method", method_name)
@@ -28,6 +28,14 @@ module Test
           unregister_fixture(:setup, *method_names)
         end
 
+        def cleanup(*method_names)
+          register_fixture(:cleanup, *method_names)
+        end
+
+        def unregister_cleanup(*method_names)
+          unregister_fixture(:cleanup, *method_names)
+        end
+
         def teardown(*method_names)
           register_fixture(:teardown, *method_names)
         end
@@ -44,6 +52,15 @@ module Test
           unregister_fixture_method(:setup, method_name)
         end
 
+        def register_cleanup_method(method_name, options)
+          register_fixture_method(:cleanup, method_name, options,
+                                  :before, :prepend)
+        end
+
+        def unregister_cleanup_method(method_name)
+          unregister_fixture_method(:cleanup, method_name)
+        end
+
         def register_teardown_method(method_name, options)
           register_fixture_method(:teardown, method_name, options,
                                   :before, :prepend)
@@ -61,6 +78,14 @@ module Test
           collect_fixture_methods(:setup, :after)
         end
 
+        def before_cleanup_methods
+          collect_fixture_methods(:cleanup, :before)
+        end
+
+        def after_cleanup_methods
+          collect_fixture_methods(:cleanup, :after)
+        end
+
         def before_teardown_methods
           collect_fixture_methods(:teardown, :before)
         end
@@ -177,6 +202,10 @@ module Test
         run_fixture(:setup)
       end
 
+      def run_cleanup
+        run_fixture(:cleanup)
+      end
+
       def run_teardown
         run_fixture(:teardown, :handle_exception => true)
       end