activeldap 0.10.0 → 1.0.0

data/test-unit-ext/lib/test-unit-ext/pending.rb

@@ -0,0 +1,97 @@
+module Test
+  module Unit
+    class TestResult
+      attr_reader :pendings
+
+      alias_method(:initialize_without_pendings, :initialize)
+      def initialize
+        initialize_without_pendings
+        @pendings = []
+      end
+
+      def add_pending(pending)
+        @pendings << pending
+        notify_listeners(FAULT, pending)
+        notify_listeners(CHANGED, self)
+      end
+
+      def pending_count
+        @pendings.size
+      end
+
+      alias_method(:to_s_without_pendings, :to_s)
+      def to_s
+        to_s_without_pendings + ", #{pending_count} pendings"
+      end
+    end
+
+    class Pending
+      include Util::BacktraceFilter
+      attr_reader :test_name, :location, :message
+      
+      SINGLE_CHARACTER = 'P'
+
+      # Creates a new Pending with the given location and
+      # message.
+      def initialize(test_name, location, message)
+        @test_name = test_name
+        @location = location
+        @message = message
+      end
+      
+      # Returns a single character representation of a pending.
+      def single_character_display
+        SINGLE_CHARACTER
+      end
+
+      # Returns a brief version of the error description.
+      def short_display
+        "#@test_name: #{@message.split("\n")[0]}"
+      end
+
+      # Returns a verbose version of the error description.
+      def long_display
+        location_display = filter_backtrace(location)[0]
+        location_display = location_display.sub(/\A(.+:\d+).*/, ' [\\1]')
+        "Pending:\n#{@test_name}#{location_display}:\n#{@message}"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+    end
+
+    class PendedError < StandardError
+    end
+
+    module AssertionsWithPend
+      def pend(message="Pended", &block)
+        if block_given?
+          begin
+            yield
+          rescue Exception
+            raise PendedError, message, $!.backtrace
+          end
+          flunk("Pending block should not be passed: #{message}")
+        else
+          raise PendedError.new(message)
+        end
+      end
+    end
+
+    class TestCase
+      include AssertionsWithPend
+
+      alias_method(:add_error_without_pending, :add_error)
+      def add_error(exception)
+        if exception.is_a?(PendedError)
+          pending = Pending.new(name, exception.backtrace, exception.message)
+          @_result.add_pending(pending)
+        else
+          add_error_without_pending(exception)
+        end
+      end
+    end
+  end
+end

data/{test → test-unit-ext/lib}/test-unit-ext/priority.rb

@@ -1,53 +1,25 @@
 require "test/unit"
 
 require "fileutils"
+require "tmpdir"
+
+require "test-unit-ext/attributes"
 
 module Test
   module Unit
     class TestCase
       class << self
-        def inherited(sub)
-          super
-          sub.instance_variable_set("@priority_initialized", true)
-          sub.instance_variable_set("@priority_table", {})
-          sub.priority :normal
-        end
-
-        def include(*args)
-          args.reverse_each do |mod|
-            super(mod)
-            next unless defined?(@priority_initialized)
-            mod.instance_methods(false).each do |name|
-              set_priority(name)
-            end
-          end
-        end
-
-        alias_method :method_added_without_priority, :method_added
-        def method_added(name)
-          method_added_without_priority(name)
-          set_priority(name) if defined?(@priority_initialized)
-        end
-
         def priority(name, *tests)
           singleton_class = (class << self; self; end)
           priority_check_method = priority_check_method_name(name)
           unless singleton_class.private_method_defined?(priority_check_method)
             raise ArgumentError, "unknown priority: #{name}"
           end
-          if tests.empty?
-            @current_priority = name
-          else
-            tests.each do |test|
-              set_priority(test, name)
-            end
-          end
+          attribute(:priority, name, {:keep => true}, *tests)
         end
 
         def need_to_run?(test_name)
-          normalized_test_name = normalize_test_name(test_name)
-          priority = @priority_table[normalized_test_name]
-          return true unless priority
+          priority = (attributes(test_name) || {})[:priority] || :normal
           __send__(priority_check_method_name(priority), test_name)
         end
 
@@ -56,10 +28,6 @@ module Test
           "run_priority_#{priority_name}?"
         end
 
-        def normalize_test_name(test_name)
-          "test_#{test_name.to_s.sub(/^test_/, '')}"
-        end
-
         def set_priority(name, priority=@current_priority)
           @priority_table[normalize_test_name(name)] = priority
         end
@@ -93,9 +61,9 @@ module Test
         !previous_test_success? or self.class.need_to_run?(@method_name)
       end
 
-      alias_method :original_run, :run
+      alias_method :run_without_priority, :run
       def run(result, &block)
-        original_run(result, &block)
+        run_without_priority(result, &block)
       ensure
         if passed?
           FileUtils.touch(passed_file)
@@ -111,18 +79,22 @@ module Test
 
       def result_dir
         components = [".test-result", self.class.name, @method_name.to_s]
-        dir = File.join(File.dirname($0), *components)
-        dir = File.expand_path(dir)
-        begin
-          FileUtils.mkdir_p(dir)
-        rescue Errno::EACCES
-          retry_dir = File.join(File.dirname(__FILE__), "..", *components)
-          retry_dir = File.expand_path(retry_dir)
-          raise if retry_dir == dir
-          dir = retry_dir
-          retry
-        end
-        dir
+        parent_directories = [File.dirname($0),
+                              File.join(File.dirname(__FILE__), ".."),
+                              Dir.pwd]
+        if Process.respond_to?(:uid)
+          parent_directories << File.join(Dir.tmpdir, Process.uid.to_s)
+        end
+        parent_directories.each do |parent_directory|
+          dir = File.expand_path(File.join(parent_directory, *components))
+          begin
+            FileUtils.mkdir_p(dir)
+            return dir
+          rescue Errno::EACCES
+          end
+        end
+
+        raise Errno::EACCES, parent_directories.join(", ")
       end
 
       def passed_file
@@ -150,14 +122,14 @@ module Test
         end
       end
 
-      alias_method :original_run, :run
+      alias_method :run_without_priority_support, :run
       def run(*args, &block)
         priority_mode = @@priority_mode
         if priority_mode
           @original_tests = @tests
           apply_priority
         end
-        original_run(*args, &block)
+        run_without_priority_support(*args, &block)
       ensure
         @tests = @original_tests if priority_mode
       end

data/test-unit-ext/lib/test-unit-ext/version.rb

@@ -0,0 +1,3 @@
+module TestUnitExt
+  VERSION = "0.6.0"
+end

data/test-unit-ext/lib/test-unit-ext/xml-report.rb

@@ -0,0 +1,224 @@
+require "erb"
+require "test/unit/failure"
+require "test/unit/error"
+require "test/unit/testresult"
+require "test/unit/testsuite"
+require "test/unit/autorunner"
+
+module Test
+  module Unit
+    module XMLReportable
+      include ERB::Util
+
+      def to_xml
+        <<-XML.gsub(/\s*(\n  <\/test>|\n<\/result>)/m, "\\1")
+<result>
+  <test_case>
+    <name>#{h(@test.class.name)}</name>
+    <description/>
+  </test_case>
+  <test>
+    <name>#{h(@test.method_name)}</name>
+    <description/>
+#{options_xml}
+  </test>
+  <status>#{h(status_name)}</status>
+  <detail>#{h(message)}</detail>
+  <elapsed>#{h(elapsed_time)}</elapsed>
+#{backtrace_xml}
+</result>
+XML
+      end
+
+      private
+      def options_xml
+        @test.attributes.collect do |key, value|
+          <<-XML
+    <option>
+      <name>#{h(key)}</name>
+      <value>#{h(value)}</value>
+    </option>
+XML
+        end.join
+      end
+
+      def backtrace_xml
+        entries = backtrace_entries_xml
+        if entries.empty?
+          ""
+        else
+          <<-XML
+  <backtrace>
+#{entries.join.rstrip}
+  </backtrace>
+XML
+        end
+      end
+
+      def backtrace_entries_xml
+        location.collect do |location|
+          file, line, info = location.split(/:(\d+):/)
+          <<-XML
+    <entry>
+      <file>#{h(file)}</file>
+      <line>#{h(line)}</line>
+      <info>#{h(info.to_s.strip)}</info>
+    </entry>
+XML
+        end
+      end
+    end
+
+    class Success
+      include XMLReportable
+
+      attr_reader :test, :elapsed_time
+      def initialize(test, elapsed_time)
+        @test = test
+        @elapsed_time = elapsed_time
+      end
+
+      def message
+        nil
+      end
+
+      def location
+        []
+      end
+
+      def test_name
+        @test.name
+      end
+
+      def test_case_name
+        /\((.*)\)\z/ =~ test_name
+        $1
+      end
+
+      def status_name
+        "success"
+      end
+    end
+
+    class Failure
+      include XMLReportable
+
+      attr_accessor :test, :elapsed_time
+
+      def status_name
+        "failure"
+      end
+    end
+
+    class Error
+      include XMLReportable
+
+      attr_accessor :test, :elapsed_time
+
+      def status_name
+        "error"
+      end
+
+      def location
+        filter_backtrace(@exception.backtrace)
+      end
+    end
+
+    class TestCase
+      alias_method(:run_without_success_notify, :run)
+      def run(result, &block)
+        @_start_time = Time.now
+        run_result = run_without_success_notify(result, &block)
+        result.add_success(Success.new(self, Time.now - @_start_time)) if passed?
+        run_result
+      end
+
+      alias_method(:add_failure_without_test_case_set, :add_failure)
+      def add_failure(*args)
+        add_failure_without_test_case_set(*args)
+        failure = @_result.failures.last
+        failure.test = self
+        failure.elapsed_time = Time.now - @_start_time
+      end
+
+      alias_method(:add_error_without_test_case_set, :add_error)
+      def add_error(*args)
+        add_error_without_test_case_set(*args)
+        error = @_result.errors.last
+        error.test = self
+        error.elapsed_time = Time.now - @_start_time
+      end
+    end
+
+    class TestResult
+      attr_reader :failures, :errors
+
+      alias_method(:initialize_without_successes, :initialize)
+      def initialize
+        initialize_without_successes
+        @successes = []
+        @logs = []
+      end
+
+      def add_success(success)
+        @logs << success
+        @successes << success
+      end
+
+      alias_method(:add_failure_without_logs_store, :add_failure)
+      def add_failure(failure)
+        @logs << failure
+        add_failure_without_logs_store(failure)
+      end
+
+      alias_method(:add_error_without_logs_store, :add_error)
+      def add_error(error)
+        @logs << error
+        add_error_without_logs_store(error)
+      end
+
+      def to_xml
+        return "<report/>" if @logs.empty?
+        xml = @logs.collect {|log| log.to_xml.gsub(/^/, "  ")}.join
+        "<report>\n#{xml}</report>\n"
+      end
+    end
+
+    class TestSuite
+      attr_reader :result
+
+      alias_method(:run_without_keep_result, :run)
+      def run(result, &block)
+        @result = result
+        run_without_keep_result(result, &block)
+      end
+    end
+
+    class AutoRunner
+      alias_method(:options_without_xml_report_support, :options)
+      def options
+        opt = options_without_xml_report_support
+        @xml_report_support_option_added ||= false
+        unless @xml_report_support_option_added
+          @xml_report_file = nil
+          opt.on('--xml-report=FILE',
+                 "Output test report in XML to FILE.") do |file|
+            @xml_report_file = file
+          end
+        end
+        opt
+      end
+
+      alias_method(:run_without_xml_report_support, :run)
+      def run
+        passed = run_without_xml_report_support
+        if @xml_report_file
+          File.open(@xml_report_file, "w") do |f|
+            f.print(@suite.result.to_xml)
+          end
+        end
+        passed
+      end
+    end
+  end
+end

data/test-unit-ext/lib/test-unit-ext.rb

@@ -0,0 +1,16 @@
+require "test/unit"
+
+require "test-unit-ext/version"
+require "test-unit-ext/color"
+require "test-unit-ext/colorized-runner"
+require "test-unit-ext/diff"
+require "test-unit-ext/always-show-result"
+require "test-unit-ext/attributes"
+require "test-unit-ext/priority"
+require "test-unit-ext/backtrace-filter"
+require "test-unit-ext/long-display-for-emacs"
+require "test-unit-ext/xml-report"
+require "test-unit-ext/assertions"
+require "test-unit-ext/pending"
+require "test-unit-ext/omission"
+require "test-unit-ext/notification"

data/test-unit-ext/misc/rd2html.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+top = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+html_dir = File.join(top, "html")
+
+require "fileutils"
+
+css = "base.css"
+kcode = "utf8"
+
+options = [
+  "-I#{File.join(top, 'misc')}",
+  "-S",
+  "rd2",
+  "-rrd/rd2html-lib",
+  "--out-code=#{kcode}",
+  proc do |f|
+    "--html-title=#{File.basename(f)}"
+  end,
+#   proc do |f|
+#     "--with-css=#{css}"
+#   end,
+  proc do |f|
+    f
+  end
+]
+
+Dir[File.join(top, "*.{ja,en}")].each do |f|
+  if /(README|NEWS)\.(ja|en)\z/ =~ f
+    args = options.collect do |x|
+      if x.respond_to?(:call)
+        x.call(f)
+      else
+        x
+      end
+    end
+    output_base = File.basename(f).downcase.sub(/(ja|en)\z/, "html.\\1")
+    File.open(File.join(html_dir, output_base), "w") do |out|
+      out.puts(`ruby #{args.flatten.join(' ')}`)
+    end
+  end
+end

data/test-unit-ext/test/run-test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift("./lib")
+$LOAD_PATH.unshift("./test")
+
+require "test-unit-ext"
+
+Dir.glob("test/**/test_*.rb") do |test|
+  begin
+    require test
+  rescue LoadError
+    puts "Can't load: #{test}: #{$!.message}"
+  end
+end

data/test-unit-ext/test/test_attributes.rb

@@ -0,0 +1,139 @@
+require 'test-unit-ext'
+
+class TestAttributes < Test::Unit::TestCase
+  class TestStack < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    class Stack
+      def initialize
+        @data = []
+      end
+
+      def push(data)
+        @data.push(data)
+      end
+
+      def peek
+        @data[-2]
+      end
+
+      def empty?
+        @data.empty?
+      end
+
+      def size
+        @data.size + 11
+      end
+    end
+
+    def setup
+      @stack = Stack.new
+    end
+
+    attribute :category, :accessor
+    def test_peek
+      @stack.push(1)
+      @stack.push(2)
+      assert_equal(2, @stack.peek)
+    end
+
+    attribute :bug, 1234
+    def test_bug_1234
+      assert_equal(0, @stack.size)
+    end
+
+    def test_no_attributes
+      assert(@stack.empty?)
+      @stack.push(1)
+      assert(!@stack.empty?)
+      assert_equal(1, @stack.size)
+    end
+  end
+
+  def test_set_attributes
+    test_for_bug_1234 = TestStack.new("test_bug_1234")
+    assert_equal({:bug => 1234}, test_for_bug_1234.attributes)
+
+    test_no_attributes = TestStack.new("test_no_attributes")
+    assert_equal({}, test_no_attributes.attributes)
+  end
+
+  def test_show_attributes
+    assert_stack_size_line = search_line('assert_equal(0, @stack.size)')
+    assert_peek_line = search_line('assert_equal(2, @stack.peek)')
+    first_arg_end_line = search_line("\"+ 11\"],")
+    method_name = "test_show_attributes"
+    assert_result(["Failure:\n" \
+                   "test_peek(TestAttributes::TestStack)\n" \
+                   "  category: accessor\n" \
+                   "#{__FILE__}:#{assert_peek_line}:in `test_peek'\n" \
+                   "#{__FILE__}:#{first_arg_end_line}:in `#{method_name}':\n" \
+                   "<2> expected but was\n" \
+                   "<1>.\n" \
+                   "\n" \
+                   "diff:\n" \
+                   "- 2\n" \
+                   "+ 1",
+                   "Failure:\n" \
+                   "test_bug_1234(TestAttributes::TestStack)\n" \
+                   "  bug: 1234\n" \
+                   "#{__FILE__}:#{assert_stack_size_line}:in `test_bug_1234'\n" \
+                   "#{__FILE__}:#{first_arg_end_line}:in `#{method_name}':\n" \
+                   "<0> expected but was\n" \
+                   "<11>.\n" \
+                   "\n" \
+                   "diff:\n" \
+                   "- 0\n" \
+                   "+ 11"],
+                  [],
+                  ["test_peek", "test_bug_1234"])
+  end
+
+  def test_not_show_attributes
+    assert_line = search_line('assert_equal(1, @stack.size')
+    first_arg_end_line = search_line("\"+ 12\"],")
+    method_name = "test_not_show_attributes"
+    assert_result(["Failure:\n" \
+                   "test_no_attributes(TestAttributes::TestStack)\n" \
+                   "#{__FILE__}:#{assert_line}:in `test_no_attributes'\n" \
+                   "#{__FILE__}:#{first_arg_end_line}:in `#{method_name}':\n" \
+                   "<1> expected but was\n" \
+                   "<12>.\n" \
+                   "\n" \
+                   "diff:\n" \
+                   "- 1\n" \
+                   "+ 12"],
+                  [],
+                  ["test_no_attributes"])
+  end
+
+  private
+  def search_line(pattern)
+    if pattern.is_a?(String)
+      pattern = /#{Regexp.escape(pattern)}/
+    end
+    File.open(__FILE__) do |file|
+      while line = file.gets
+        return file.lineno if pattern =~ line
+      end
+    end
+    nil
+  end
+
+  def assert_result(failure_results, error_results, names)
+    tests = names.collect {|name| TestStack.new(name)}
+    result = Test::Unit::TestResult.new
+    mark = /\A#{Regexp.escape(__FILE__)}:#{__LINE__ + 1}/
+    tests.each {|test| test.run(result) {}}
+    failures = result.instance_variable_get("@failures")
+    errors = result.instance_variable_get("@errors")
+    failures.each {|f| f.location.reject! {|l| mark =~ l}}
+    assert_equal([failure_results, error_results],
+                 [failures.collect {|failure| failure.long_display},
+                  errors.collect {|error| error.long_display}])
+  end
+end