activeldap 0.10.0 → 1.0.0

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

@@ -0,0 +1,129 @@
+require "test/unit"
+
+module Test
+  module Unit
+    class TestCase
+      class << self
+        alias_method :method_added_without_attributes, :method_added
+        def method_added(name)
+          method_added_without_attributes(name)
+          if defined?(@current_attributes)
+            attributes = {}
+            kept_attributes = {}
+            @current_attributes.each do |attribute_name, attribute|
+              attributes[attribute_name] = attribute[:value]
+              kept_attributes[attribute_name] = attribute if attribute[:keep]
+            end
+            set_attributes(name, attributes)
+            @current_attributes = kept_attributes
+          end
+        end
+
+        def attribute(name, value, options={}, *tests)
+          unless options.is_a?(Hash)
+            tests << options
+            options = {}
+          end
+          @current_attributes ||= {}
+          if tests.empty?
+            @current_attributes[name] = options.merge(:value => value)
+          else
+            tests.each do |test|
+              set_attribute(test, {name => value})
+            end
+          end
+        end
+
+        def bug(value, *tests)
+          attribute(:bug, value, *tests)
+        end
+
+        def set_attributes(test_name, attributes)
+          return if attributes.empty?
+          test_name = normalize_test_name(test_name)
+          @attributes ||= {}
+          @attributes[test_name] ||= {}
+          @attributes[test_name] = @attributes[test_name].merge(attributes)
+        end
+
+        def attributes(test_name)
+          test_name = normalize_test_name(test_name)
+          @attributes ||= {}
+          @attributes[test_name]
+        end
+
+        private
+        def normalize_test_name(test_name)
+          "test_#{test_name.to_s.sub(/^test_/, '')}"
+        end
+      end
+
+      alias_method :run_without_attributes, :run
+      def run(result, &block)
+        run_without_attributes(TestResultAttributesSupport.new(result, self),
+                               &block)
+      end
+
+      def attributes
+        self.class.attributes(@method_name) || {}
+      end
+    end
+
+    class TestResultAttributesSupport
+      def initialize(result, test)
+        @result = result
+        @test = test
+      end
+
+      def add_failure(failure)
+        failure.attributes = @test.attributes
+        method_missing(:add_failure, failure)
+      end
+
+      def add_error(error)
+        error.attributes = @test.attributes
+        method_missing(:add_error, error)
+      end
+
+      def method_missing(name, *args, &block)
+        @result.send(name, *args, &block)
+      end
+    end
+
+    module AttributesFormatter
+      private
+      def format_attributes
+        return '' if attributes.empty?
+        attributes.collect do |key, value|
+          "  #{key}: #{value}"
+        end.join("\n") + "\n"
+      end
+    end
+
+    class Failure
+      include AttributesFormatter
+
+      attr_accessor :attributes
+
+      alias_method :long_display_without_attributes, :long_display
+      def long_display
+        test_name_re = Regexp.escape(@test_name)
+        long_display_without_attributes.sub(/(^#{test_name_re}.*\n)/,
+                                            "\\1#{format_attributes}")
+      end
+    end
+
+    class Error
+      include AttributesFormatter
+
+      attr_accessor :attributes
+
+      alias_method :long_display_without_attributes, :long_display
+      def long_display
+	test_name_re = Regexp.escape(@test_name)
+        long_display_without_attributes.sub(/(^#{test_name_re}:\n)/,
+                                            "\\1#{format_attributes}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Test
+  class Color
+    NAMES = ["black", "red", "green", "yellow",
+             "blue", "magenta", "cyan", "white"]
+    def initialize(name, options={})
+      @name = name
+      @foreground = options[:foreground]
+      @foreground = true if @foreground.nil?
+      @intensity = options[:intensity]
+      @bold = options[:bold]
+      @italic = options[:italic]
+      @underline = options[:underline]
+    end
+
+    def sequence
+      sequence = []
+      if @name == "none"
+      elsif @name == "reset"
+        sequence << "0"
+      else
+        foreground_parameter = @foreground ? 3 : 4
+        foreground_parameter += 6 if @intensity
+        sequence << "#{foreground_parameter}#{NAMES.index(@name)}"
+      end
+      sequence << "1" if @bold
+      sequence << "3" if @italic
+      sequence << "4" if @underline
+      sequence
+    end
+
+    def escape_sequence
+      "\e[#{sequence.join(';')}m"
+    end
+
+    def +(other)
+      MixColor.new([self, other])
+    end
+  end
+
+  class MixColor
+    def initialize(colors)
+      @colors = colors
+    end
+
+    def sequence
+      @colors.inject([]) do |result, color|
+        result + color.sequence
+      end
+    end
+
+    def escape_sequence
+      "\e[#{sequence.join(';')}m"
+    end
+
+    def +(other)
+      self.class.new([self, other])
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+require "test/unit/ui/console/testrunner"
+
+module Test
+  module Unit
+    module UI
+      module Console
+        class ColorizedTestRunner < TestRunner
+          extend TestRunnerUtilities
+
+          SCHEMES = {
+            :default => {
+              "success" => Color.new("green", :bold => true),
+              "failure" => Color.new("red", :bold => true),
+              "pending" => Color.new("magenta", :bold => true),
+              "omission" => Color.new("blue", :bold => true),
+              "notification" => Color.new("cyan", :bold => true),
+              "error" => Color.new("yellow", :bold => true),
+            },
+          }
+
+          def initialize(suite, output_level=NORMAL, io=STDOUT)
+            super
+            @use_color = guess_color_availability
+            @color_scheme = SCHEMES[:default]
+            @reset_color = Color.new("reset")
+          end
+
+          private
+          def add_fault(fault)
+            @faults << fault
+            output_single_with_color(fault.single_character_display,
+                                     fault_color(fault),
+                                     PROGRESS_ONLY)
+            @already_outputted = true
+          end
+
+          def test_finished(name)
+            unless @already_outputted
+              output_single_with_color(".",
+                                       @color_scheme["success"],
+                                       PROGRESS_ONLY)
+            end
+            nl(VERBOSE)
+            @already_outputted = false
+          end
+
+          def finished(elapsed_time)
+            nl
+            output("Finished in #{elapsed_time} seconds.")
+            @faults.each_with_index do |fault, index|
+              nl
+              output_single("%3d) " % (index + 1))
+              output_with_color(fault.long_display, fault_color(fault))
+            end
+            nl
+            output_with_color(@result.to_s, result_color)
+          end
+
+          def fault_color(fault)
+            @color_scheme[fault.class.name.split(/::/).last.downcase]
+          end
+
+          def result_color
+            if @result.passed?
+              if @result.pending_count > 0
+                @color_scheme["pending"]
+              elsif @result.notification_count > 0
+                @color_scheme["notification"]
+              else
+                @color_scheme["success"]
+              end
+            elsif @result.error_count > 0
+              @color_scheme["error"]
+            elsif @result.failure_count > 0
+              @color_scheme["failure"]
+            end
+          end
+
+          def output_with_color(message, color=nil, level=NORMAL)
+            return unless output?(level)
+            output_single_with_color(message, color, level)
+            @io.puts
+          end
+
+          def output_single_with_color(message, color=nil, level=NORMAL)
+            return unless output?(level)
+            if @use_color and color
+              message = "%s%s%s" % [color.escape_sequence,
+                                    message,
+                                    @reset_color.escape_sequence]
+            end
+            @io.write(message)
+            @io.flush
+          end
+
+          def guess_color_availability
+            return false unless @io.tty?
+            term = ENV["TERM"]
+            return true if term and (/term\z/ =~ term or term == "screen")
+            return true if ENV["EMACS"] == "t"
+            false
+          end
+        end
+      end
+    end
+
+    AutoRunner::RUNNERS[:console] = Proc.new do
+      Test::Unit::UI::Console::ColorizedTestRunner
+    end
+  end
+end