minitest_log 0.1.0

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/helpers/array_helper.rb

@@ -0,0 +1,31 @@
+require 'diff/lcs'
+
+class ArrayHelper
+
+  # Compare two arrays.
+  def self.compare(expected, actual)
+    sdiff = Diff::LCS.sdiff(expected, actual)
+    changes = {}
+    action_words = {
+        '!' => 'changed',
+        '+' => 'unexpected',
+        '-' => 'missing',
+        '=' => 'unchanged'
+    }
+    sdiff.each_with_index do |change, i|
+      action_word = action_words.fetch(change.action)
+      key = "change_#{i}"
+      attrs = %W/
+          action=#{action_word}
+          old_pos=#{change.old_position}
+          old_ele=#{change.old_element}
+          new_pos=#{change.old_position}
+          new_ele=#{change.old_element}
+      /
+      value = attrs.join(' ')
+      changes.store(key, value)
+    end
+    {:sdiff => changes}
+  end
+
+end

data/lib/helpers/hash_helper.rb

@@ -0,0 +1,32 @@
+class HashHelper
+
+  # Compare two hashes.
+  # Returns a hash with keys +:ok+, +:missing+, +:unexpected+, +:changed+.
+  def self.compare(expected, actual)
+    result = {
+        :missing => {},
+        :unexpected => {},
+        :changed => {},
+        :ok => {},
+    }
+    expected.each_pair do |key_expected, value_expected|
+      if actual.include?(key_expected)
+        value_actual = actual[key_expected]
+        if value_actual == value_expected
+          result[:ok][key_expected] = value_expected
+        else
+          result[:changed][key_expected] = {:expected => value_expected, :actual => value_actual}
+        end
+      else
+        result[:missing][key_expected] = value_expected
+      end
+    end
+    actual.each_pair do |key_actual, value_actual|
+      next if expected.include?(key_actual)
+      result[:unexpected][key_actual] = value_actual
+    end
+    result
+  end
+
+end
+

data/lib/helpers/set_helper.rb

@@ -0,0 +1,14 @@
+class SetHelper
+
+  # Compare two sets.
+  # Returns a hash with keys +:ok+, +:missing+, +:unexpected+.
+  def self.compare(expected, actual)
+    {
+        :missing => expected - actual,
+        :unexpected => actual - expected,
+        :ok => expected & actual,
+    }
+  end
+
+end
+

data/lib/minitest_log.rb

@@ -0,0 +1,498 @@
+require 'rexml/document'
+require 'minitest/autorun'
+require 'minitest/assertions'
+require 'diff/lcs'
+
+require_relative 'verdict_assertion'
+
+class MinitestLog
+
+  include VerdictAssertion
+
+  attr_accessor \
+    :assertions,
+    :counts,
+    :file,
+    :file_path,
+    :backtrace_filter,
+    :root_name,
+    :verdict_ids,
+    :xml_indentation,
+    :error_verdict,
+    :summary
+
+  include REXML
+  include Minitest::Assertions
+
+  class MinitestLogError < Exception; end
+  class NoBlockError < MinitestLogError; end
+  class DuplicateVerdictIdError < MinitestLogError; end
+  class IllegalElementNameError < MinitestLogError; end
+  class IllegalNewError < MinitestLogError; end
+
+  def initialize(file_path, options=Hash.new)
+    raise NoBlockError.new('No block given for MinitestLog#new.') unless (block_given?)
+    default_options = Hash[
+        :root_name => 'log',
+        :xml_indentation => 2,
+        :error_verdict => false,
+        :summary => false
+    ]
+    options = default_options.merge(options)
+    self.assertions = 0
+    self.file_path = file_path
+    self.root_name = options[:root_name]
+    self.xml_indentation = options[:xml_indentation]
+    self.summary = options[:summary]
+    self.error_verdict = options[:error_verdict] || false
+    self.backtrace_filter = options[:backtrace_filter] || /minitest/
+    self.file = File.open(self.file_path, 'w')
+    log_puts("REMARK\tThis text log is the precursor for an XML log.")
+    log_puts("REMARK\tIf the logged process completes, this text will be converted to XML.")
+    log_puts("BEGIN\t#{self.root_name}")
+    self.counts = Hash[
+        :verdict => 0,
+        :failure => 0,
+        :error => 0,
+    ]
+    begin
+      yield self
+    rescue => x
+      put_element('uncaught_exception', :timestamp, :class => x.class) do
+        put_element('message', x.message)
+        put_element('backtrace') do
+          backtrace = filter_backtrace(x.backtrace)
+          put_pre(backtrace.join("\n"))
+        end
+      end
+    end
+    dispose
+    nil
+  end
+
+  def section(name, *args)
+    put_element('section', {:name => name}, *args) do
+      yield if block_given?
+    end
+    nil
+  end
+
+  def comment(text)
+    if text.match("\n")
+      # Separate text from containing punctuation.
+      put_element('comment') do
+        cdata("\n#{text}\n")
+      end
+    else
+      put_element('comment', text)
+    end
+    nil
+  end
+
+  def put_element(element_name = 'element', *args)
+    if false ||
+        caller[0].match(/minitest_log.rb/) ||
+        caller[0].match(/verdict_assertion.rb/)
+      # Make the element name special.
+      element_name += '_'
+    elsif element_name.end_with?('_')
+      # Don't accept user's special.
+      message = "Element name should not end with underscore: #{element_name}"
+      raise IllegalElementNameError.new(message)
+    else
+      # Ok.
+    end
+    attributes = {}
+    pcdata = ''
+    start_time = nil
+    duration_to_be_included = false
+    block_to_be_rescued = false
+    args.each do |arg|
+      case
+      when arg.kind_of?(Hash)
+        attributes.merge!(arg)
+      when arg.kind_of?(String)
+        pcdata += arg
+      when arg == :timestamp
+        attributes[:timestamp] = MinitestLog.timestamp
+      when arg == :duration
+        duration_to_be_included = true
+      when arg == :rescue
+        block_to_be_rescued = true
+      else
+        pcdata = pcdata + arg.inspect
+      end
+    end
+    log_puts("BEGIN\t#{element_name}")
+    put_attributes(attributes)
+    unless pcdata.empty?
+      # Guard against using a terminator that's a substring of pcdata.
+      s = 'EOT'
+      terminator = s
+      while pcdata.match(terminator) do
+        terminator += s
+      end
+      log_puts("PCDATA\t<<#{terminator}")
+      log_puts(pcdata)
+      log_puts(terminator)
+    end
+    start_time = Time.new if duration_to_be_included
+    if block_given?
+      if block_to_be_rescued
+        begin
+          yield
+        rescue Exception => x
+          put_element('rescued_exception', {:class => x.class, :message => x.message}) do
+            put_element('backtrace') do
+              backtrace = filter_backtrace(x.backtrace)
+              put_pre(backtrace.join("\n"))
+            end
+          end
+          self.counts[:error] += 1
+        end
+      else
+        yield
+      end
+    end
+    if start_time
+      end_time = Time.now
+      duration_f = end_time.to_f - start_time.to_f
+      duration_s = format('%.3f', duration_f)
+      put_attributes({:duration_seconds => duration_s})
+    end
+    log_puts("END\t#{element_name}")
+    nil
+  end
+
+  def put_each_with_index(name, obj)
+    lines = ['']
+    obj.each_with_index do |item, i|
+      lines.push(format('%d: %s', i, item.to_s))
+    end
+    attrs = {
+        :name => name,
+        :class => obj.class,
+        :method => ':each_with_index',
+    }
+    add_attr_if(attrs, obj, :size)
+    put_element('data', attrs) do
+      put_pre(lines.join("\n"))
+    end
+    nil
+  end
+  alias put_array put_each_with_index
+  alias put_set put_each_with_index
+
+  def put_each(name, obj)
+    lines = ['']
+    obj.each do |item|
+      lines.push(item)
+    end
+    attrs = {
+        :name => name,
+        :class => obj.class,
+        :method => ':each',
+    }
+    add_attr_if(attrs, obj, :size)
+    put_element('data', attrs) do
+      put_pre(lines.join("\n"))
+    end
+    nil
+  end
+
+  def put_each_pair(name, obj)
+    lines = ['']
+    obj.each_pair do |key, value|
+      lines.push(format('%s => %s', key, value))
+    end
+    attrs = {
+        :name => name,
+        :class => obj.class,
+        :method => ':each_pair',
+    }
+    add_attr_if(attrs, obj, :size)
+    put_element('data', attrs) do
+      put_pre(lines.join("\n"))
+    end
+    nil
+  end
+  alias put_hash put_each_pair
+
+  def put_to_s(name, obj)
+    put_element('data',  obj.to_s, :name => name, :class => obj.class, :method => ':to_s')
+  end
+
+  def put_string(name, obj)
+    put_element('data',  obj.to_s, :name => name, :class => obj.class, :size => obj.size)
+  end
+
+  def put_inspect(name, obj)
+    put_element('data',  obj.inspect, :name => name, :class => obj.class, :method => ':inspect')
+  end
+
+  def put_id(name, obj)
+    put_element('data', :name => name, :class => obj.class, :id => obj.__id__)
+  end
+
+  def put_data(name, obj)
+    case
+    when obj.kind_of?(String)
+      put_string(name, obj)
+    when obj.respond_to?(:each_pair)
+      put_each_pair(name, obj)
+    when obj.respond_to?(:each_with_index)
+      put_each_with_index(name, obj)
+    when obj.respond_to?(:each)
+      put_each(name, obj)
+    when obj.respond_to?(:to_s)
+      put_to_s(name, obj)
+    when obj.respond_to?(:inspect)
+      put_inspect(name, obj)
+    when obj.respond_to?(:__id__)
+      put_id(name, obj)
+    else
+      message = "Object does not respond to method :__id__: name=#{name}, obj=#{obj}"
+      raise ArgumentError.new(message)
+    end
+  end
+
+  def put_pre(text, verbatim = false)
+    if verbatim
+      put_cdata(text)
+    else
+      t = text.clone
+      until t.start_with?("\n")
+        t = "\n" + t
+      end
+      until t.end_with?("\n\n")
+        t = t + "\n"
+      end
+      put_cdata(t)
+    end
+  end
+
+  private
+
+  def dispose
+
+    # Add a verdict for the error count, if needed.
+    if self.error_verdict
+      verdict_assert_equal?('error_count', 0, self.counts[:error])
+    end
+
+    # Close the text log.
+    log_puts("END\t#{self.root_name}")
+    self.file.close
+
+    # Create the xml log.
+    document = REXML::Document.new
+    File.open(self.file_path, 'r') do |file|
+      element = document
+      stack = Array.new
+      data_a = Array.new
+      terminator = nil
+      file.each_line do |line|
+        line.chomp!
+        line_type, text = line.split("\t", 2)
+        case line_type
+          when 'REMARK'
+            next
+          when 'BEGIN'
+            element_name = text
+            element = element.add_element(element_name)
+            stack.push(element)
+            if stack.length == 1 && self.summary
+              summary_element = element.add_element('summary_')
+              summary_element.add_attribute('verdicts', self.counts[:verdict].to_s)
+              summary_element.add_attribute('failures', self.counts[:failure].to_s)
+              summary_element.add_attribute('errors', self.counts[:error].to_s)
+            end
+          when 'END'
+            stack.pop
+            element = stack.last
+          when 'ATTRIBUTE'
+            attr_name, attr_value = text.split("\t", 2)
+            element.add_attribute(attr_name, attr_value)
+          when 'CDATA'
+            stack.push(:cdata)
+            data_a = Array.new
+            terminator = text.split('<<', 2).last
+          when 'PCDATA'
+            stack.push(:pcdata)
+            data_a = Array.new
+            terminator = text.split('<<', 2).last
+          when terminator
+            data_s = data_a.join("\n")
+            data_a = Array.new
+            terminator = nil
+            data_type = stack.last
+            case data_type
+              when :cdata
+                cdata = CData.new(data_s)
+                element.add(cdata)
+              when :pcdata
+                element.add_text(data_s)
+              else
+                # Don't want to raise an exception and spoil the run
+            end
+            stack.pop
+          else
+            data_a.push(line) if (terminator)
+        end
+      end
+      document << XMLDecl.default
+    end
+
+    File.open(self.file_path, 'w') do |file|
+      document.write(file, self.xml_indentation)
+    end
+    # Trailing newline.
+    File.open(self.file_path, 'a') do |file|
+      file.write("\n")
+    end
+    nil
+  end
+
+  def _get_verdict?(verdict_method, verdict_id, message, args_hash)
+    assertion_method = assertion_method_for(verdict_method)
+    if block_given?
+      outcome, exception = get_assertion_outcome(verdict_id, assertion_method, *args_hash.values) do
+        yield
+      end
+    else
+      outcome, exception = get_assertion_outcome(verdict_id, assertion_method, *args_hash.values)
+    end
+    element_attributes = {
+        :method => verdict_method,
+        :outcome => outcome,
+        :id => verdict_id,
+    }
+    element_attributes.store(:message, message) unless message.nil?
+    put_element('verdict', element_attributes) do
+      args_hash.each_pair do |k, v|
+        put_element(k.to_s, {:class => v.class, :value => v.inspect})
+      end
+      if exception
+        self.counts[:failure] += 1
+        # If the encoding is not UTF-8, a string will have been added.
+        # Remove it, so that the message is the same on all platforms.
+        conditioned_message = exception.message.gsub("# encoding: UTF-8\n", '')
+        put_element('exception', {:class => exception.class, :message => conditioned_message}) do
+          put_element('backtrace') do
+            backtrace = filter_backtrace(exception.backtrace)
+            put_pre(backtrace.join("\n"))
+          end
+        end
+      end
+    end
+    outcome == :passed
+  end
+
+  def put_attributes(attributes)
+    attributes.each_pair do |name, value|
+      value = case
+                when value.is_a?(String)
+                  value
+                when value.is_a?(Symbol)
+                  value.to_s
+                else
+                  value.inspect
+              end
+      log_puts("ATTRIBUTE\t#{name}\t#{value}")
+    end
+    nil
+  end
+
+  def log_puts(text)
+    self.file.puts(text)
+    self.file.flush
+    nil
+  end
+
+  def validate_verdict_id(verdict_id)
+    self.verdict_ids ||= Set.new
+    if self.verdict_ids.include?(verdict_id)
+      message = format('Duplicate verdict id %s;  must be unique within its test method', verdict_id.inspect)
+      raise DuplicateVerdictIdError.new(message)
+    end
+    self.verdict_ids.add(verdict_id)
+    nil
+  end
+
+  def put_cdata(text)
+    # Guard against using a terminator that's a substring of the cdata.
+    s = 'EOT'
+    terminator = s
+    while text.match(terminator) do
+      terminator += s
+    end
+    log_puts("CDATA\t<<#{terminator}")
+    log_puts(text)
+    log_puts(terminator)
+    nil
+  end
+
+  def get_assertion_outcome(verdict_id, assertion_method, *assertion_args)
+    validate_verdict_id(verdict_id)
+    self.counts[:verdict] += 1
+    begin
+      if block_given?
+        send(assertion_method, *assertion_args) do
+          yield
+        end
+      else
+        send(assertion_method, *assertion_args)
+      end
+      return :passed, nil
+    rescue Minitest::Assertion => x
+      return :failed, x
+    end
+  end
+
+  # Filters lines that are from ruby or log, to make the backtrace more readable.
+  def filter_backtrace(lines)
+    filtered = []
+    lines.each do |line|
+      unless line.match(self.backtrace_filter)
+        filtered.push(line)
+      end
+    end
+    filtered
+  end
+
+  # Return a timestamp string.
+  # The important property of this string
+  # is that it can be incorporated into a legal directory path
+  # (i.e., has no colons, etc.).
+  def self.timestamp
+    now = Time.now
+    ts = now.strftime('%Y-%m-%d-%a-%H.%M.%S')
+    usec_s = (now.usec / 1000).to_s
+    while usec_s.length < 3 do
+      usec_s = '0' + usec_s
+    end
+    # noinspection RubyUnusedLocalVariable
+    ts += ".#{usec_s}"
+  end
+
+  def assertion_method_for(verdict_method)
+    # Our verdict method name is just an assertion method name
+    # with prefixed 'verdict_' and suffixed '?'.
+    # Just remove them to form the assertion method name.
+    verdict_method.to_s.sub('verdict_', '').sub('?', '').to_sym
+  end
+
+  def add_attr_if(attrs, obj, method)
+    return unless obj.respond_to?(method)
+    attrs[method] = obj.send(method)
+  end
+
+  def self.parse(file_path)
+    document = nil
+    File.open(file_path) do |file|
+      document = REXML::Document.new(file)
+    end
+    document
+  end
+
+end