quarry 0.3.0 → 0.4.0

data/work/sandbox/x_isotest.rb

@@ -0,0 +1,532 @@
+#!/usr/bin/env ruby
+
+require 'facets/core/hash/rekey'
+require 'facets/core/string/margin'
+require 'facets/more/progressbar'
+
+require 'test/unit/ui/testrunnermediator' #require 'test/unit'
+::Test::Unit.run = true # Don't autorun tests!
+
+class Project
+
+  # Define testing tasks.
+
+  def task_test()
+
+    #desc "Run unit tests"
+    #task :run do
+    #  project.run_iso_tests  # TODO Fix
+    #end
+
+    desc "Run isolated unit test"
+    task :test do
+      project.run_isotests
+    end
+
+    desc "Extract embedded tests"
+    task :tests do
+      project.extract_tests
+    end
+
+    desc "Run syntax check"
+    task :syntax do
+      project.test_syntax
+    end
+
+    desc 'Test load dependencies'
+    task :load do
+      project.test_load
+    end
+
+  end
+
+  # Default test files to run.
+  DEFAULT_TEST_FILES = [ 'test/**/tc*.rb', 'test/**/test*.rb', 'test/**/*test.rb' ]
+  DEFAULT_SCRIPT_FILES = [ 'lib/**/*.rb' ]
+
+  # Test syntax.
+
+  def test_syntax
+    res = true
+    cnt = 0
+    scripts = info.scripts || DEFAULT_SCRIPT_FILES
+    scripts = Dir.multiglob(*scripts) - Dir.multiglob_r(ignore)
+    scripts.each do |s|
+      next unless File.file?(s)
+      if not system "ruby -c -Ibin:lib:test #{s} &> /dev/null" then
+        puts "Syntax Error: #{s}"
+        checklist << :syntax
+        cnt += 1
+        res = false
+      end
+    end
+    if cnt == 0
+      puts "Syntax       [PASS]"
+    else
+      puts "Syntax       [FAIL]"
+    end
+    return res
+  end
+
+  # Test load dependencies.
+
+  def test_load
+    res = true
+    cnt = 0
+    tests = info.test_files || DEFAULT_TEST_FILES
+    tests = Dir.multiglob(*tests)
+    tests.each do |t|
+      if not system "ruby -Ibin:lib:test #{t} &> /dev/null" then
+        puts "Load Issue: #{t}"
+        checklist << :load
+        cnt += 1
+        res = false
+      end
+    end
+    if cnt == 0
+      puts "Load         [PASS]"
+    else
+      puts "Load         [FAIL]"
+    end
+    #puts "#{cnt} Dependency Issues"
+    return res
+  end
+
+  # Run unit-tests. Each test is run in a separate interpretor
+  # to prevent script clash. This makes for a more robust test
+  # facility and prevents potential conflicts between test scripts.
+  #
+  #   tests     Test files (eg. test/tc_**/*.rb) [test/**/*]
+  #   libs      Directories to include in load path.
+  #             ('./lib' is always included)
+  #   live      Deactive use of local libs and test against install.
+  #   reqs      List of files to require prior to running tests.
+  #   extract   Extract embedded tests first? [false]
+  #
+  # To isolate tests this tool marshals test results across a
+  # stdout->stdin shell pipe. This prevents interfence of one
+  # script's tests on another. But consequently it is not always
+  # possible to send debug info to stdout in the tests themselves
+  # (eg. #p and #puts).
+
+  def run_isotests
+    tests   = info.test_files
+    libs    = info.test_libpath
+    reqs    = info.test_require
+    live    = info.test_live
+    extract = info.test_extract
+
+    tests = [ tests ].flatten
+    libs  = [ libs ].flatten
+
+    #files = [ @files ].flatten
+    extract_tests if extract
+
+    results  = TestResults.new #(style)
+
+    # get test files
+    test_libs  = libs.join(':')
+    test_files = Dir.multiglob( *tests )
+    if test_files.empty?
+      puts "Tests        [NONE]"
+      return
+    end
+
+    # run tests
+
+    if trace?
+      pbar = nil
+      size = test_files.collect{|f| f.size}.max + 5
+      dots = '.' * size
+    else
+      pbar = Console::ProgressBar.new( 'Testing', test_files.size )
+      pbar.inc
+    end
+
+    test_files.each do |test_file|
+      pbar.inc if pbar
+      if ! File.file?(test_file)
+        next #r = nil
+      else
+        unless pbar
+          print test_file + dots[test_file.size..-1]
+          $stdout.flush
+        end
+        r = fork_test( test_file, :libs=>libs, :reqs=>reqs, :live=>live )
+        unless pbar
+          puts r.passed? ? "[PASS]" : "[FAIL]"
+        end
+      end
+      results << r
+    end
+
+    pbar.finish if pbar
+
+    # display results
+    puts results
+
+    fails, errrs = results.failure_count, results.error_count
+    CHECKLIST << :test if fails > 0
+    CHECKLIST << :test if errrs > 0
+    return (fails + errrs > 0)
+  end
+
+  # Run a test in a separate process.
+  #
+  # Currently send program output to null device.
+  # Could send to a logger in future version.
+  #
+  # Key parameters are libs, reqs, live.
+
+  def fork_test( file, keys )
+    keys = keys.rekey(:to_s)
+
+    libs = keys['lib'] || []
+    reqs = keys['req'] || []
+    live = keys['live']
+
+    src = ''
+
+    unless live
+      l = File.join( Dir.pwd, 'lib' )
+      if File.directory?( l )
+        src << %{$:.unshift('#{l}')\n}
+      end
+      libs.each { |r| src << %{$:.unshift('#{r}')\n} }
+    end
+
+    src << %{
+      #require 'test/unit'
+      require 'test/unit/collector'
+      require 'test/unit/collector/objectspace'
+      require 'test/unit/ui/testrunnermediator'
+    }
+
+    reqs.each do |fix|
+      src << %Q{
+        require '#{fix}'
+      }
+    end
+
+    src << %{
+      def warn(*null); end  # silence warnings
+
+      output = STDOUT.dup
+      STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
+
+      load('#{file}')
+      tests = Test::Unit::Collector::ObjectSpace.new.collect
+      runner = Test::Unit::UI::TestRunnerMediator.new( tests )
+      result = runner.run_suite
+
+      begin
+        marshalled = Marshal.dump(result)
+      rescue TypeError => e
+        $stderr << "MARSHAL ERROR\n"
+        $stderr << "TEST: #{file}\n"
+        $stderr << "DATA:" << result.inspect
+        exit -1
+      end
+      output << marshalled
+
+      STDOUT.reopen(output)
+      output.close
+    }
+
+    result = IO.popen("ruby","w+") do |ruby|
+      ruby.puts src
+      ruby.close_write
+      ruby.read
+    end
+
+    begin
+      marsh = Marshal.load(result)
+    rescue ArgumentError
+      $stderr << "\nCannot load marshalled test data.\n"
+      $stderr << result << "\n"
+      exit -1
+    end
+
+    return marsh
+  end
+
+  #
+  # Support class for collecting test results.
+  #
+
+  class TestResults
+    attr_reader :assertion_count,
+                :run_count,
+                :failure_count,
+                :error_count
+
+    attr_accessor :style
+
+    def initialize( style=nil )
+      @style = style
+
+      @results = []
+
+      @assertion_count = 0
+      @run_count = 0
+      @failure_count = 0
+      @error_count = 0
+    end
+
+    # Add a result to the results collection.
+
+    def <<( result )
+      @results << result
+
+      @assertion_count += result.assertion_count
+      @run_count += result.run_count
+      @failure_count += result.failure_count
+      @error_count += result.error_count
+    end
+
+    #
+
+    def errors
+      errors = []
+      @results.each do |r|
+        unless r.passed?
+          errors << r.instance_variable_get('@errors')
+        end
+      end
+      errors.reject! { |e| e == [] }
+      errors
+    end
+
+    #
+
+    def failures
+      failures = []
+      @results.each do |r|
+        unless r.passed?
+          failures << r.instance_variable_get('@failures')
+        end
+      end
+      failures.reject! { |e| e == [] }
+      failures
+    end
+
+    # Output format for test results.
+
+    def to_s
+      return @results.to_s if style == 'pease'
+
+      s = []
+      # Display failures
+      unless failures.empty?
+        s << ''
+        s << "FAILURES:"
+        failures.reverse.each do |fails|
+          fails.reverse.each do |failure|
+            #puts
+            s << %{  - test      : #{failure.test_name}}
+            s << %{    location  : #{failure.location}}
+            if failure.message.index("\n")
+              s << %{    message   : >}
+              s << failure.message.tabto(6)
+            else
+              s << %{    message   : #{failure.message}}
+            end
+          end
+        end
+      end
+
+      # Display errors
+      unless errors.empty?
+        s << ''
+        s << "ERRORS:"
+        errors.reverse.each do |errs|
+          errs.reverse.each do |err|
+            s << ''
+            s << %{  - test      : #{err.test_name}}
+            s << %{    message   : #{err.exception.message}}
+            s << %{    backtrace :}
+            err.exception.backtrace[0...-1].each { |bt| s << %Q{      - #{bt}} }
+          end
+        end
+      end
+
+      # Display final results
+      s << ''
+      s << "Summary:"
+      s << "  Tests      : #{@run_count}"
+      s << "  Assertions : #{@assertion_count}"
+      s << "  Failures   : #{@failure_count}"
+      s << "  Errors     : #{@error_count}"
+      s << ''
+      s << ''
+
+      return s.join("\n")
+    end
+
+    # Delegate missing call to the results array.
+
+    def method_missing(*a,&b)
+      @results.send(*a,&b)
+    end
+  end
+
+  # Extract unit tests. This task scans every package script
+  # looking for sections of the form:
+  #
+  #     =begin test
+  #       ...
+  #     =end
+  #
+  # With appropriate headers, it copies these sections to files
+  # in your project's test/ dir, which then can be run using the
+  # Ratchet test task. The exact directory layout of the files to
+  # be tested is reflected in the test directory. You can then
+  # use project.rb's test task to run the tests.
+  #
+  #     files      Files to extract ['lib/**/*.rb']
+  #     output     Test directory   ['test/']
+  #
+
+  def extract_tests
+    #files  = info.extract
+    files  = ['lib/**/*.rb']  # FIXME Includes everthing? Perhaps extracts should be configurable.
+    output = 'test'           # Don't think output should be setable.
+
+    filelist = Dir.multiglob(*files)
+    if filelist.empty?
+      puts "No script files found."
+      return
+    end
+
+    mkdir_p(output) unless File.directory?(output)
+
+    if trace?
+      pbar = nil
+      dots = '.' * (filelist.collect{ |f| f.size }.max + 11)
+    else
+      pbar = Console::ProgressBar.new('Extracting', filelist.size)
+      pbar.inc
+    end
+
+    filelist.each do |file|
+      if pbar
+        pbar.inc
+      else
+        print file + dots[file.size..-1]
+        $stdout.flush
+      end
+      testing = extract_test_from_file( file )
+      if testing.strip.empty?
+        puts "[NONE]" unless pbar
+      else
+        complete_test = create_test( testing, file )
+        libpath = File.dirname( file )
+        testfile = "test_" + File.basename( file )
+        fp = File.join( output, libpath, testfile )
+        unless File.directory?( File.dirname( fp ) )
+          FileUtils.mkdir_p( File.dirname(fp) )
+        end
+        File.open( fp, "w" ) { |fw| fw << complete_test }
+        puts "[TEST]" unless pbar
+      end
+    end
+    pbar ? pbar.finish : puts
+  end
+
+  private
+
+  # Extract test from a file's testing comments.
+
+  def extract_test_from_file( file )
+    return nil if ! File.file?( file )
+    tests = ""; inside = false
+    fstr = File.read( file )
+    fstr.split(/\n/).each do |l|
+      if l =~ /^=begin[ ]*test/i
+        tests << "\n"
+        inside = true
+        next
+      elsif inside and l =~ /^=[ ]*end/
+        inside = false
+        next
+      end
+      if inside
+        tests << l << "\n"
+      end
+    end
+    tests
+  end
+
+  # Generate the test.
+
+  def create_test( testing, file )
+    fp = file.split(/[\/]/)
+    if fp[0] == 'lib'
+      reqf = "require '#{fp[1..-1].join('/')}'"
+    else
+      reqf = ''
+    end
+    teststr = <<-HERE.margin
+      `#  _____         _
+      `# |_   _|__  ___| |_
+      `#   | |/ _ \\/ __| __|
+      `#   | |  __/\\__ \\ |_
+      `#   |_|\\___||___/\\__|
+      `#
+      `# for #{file}
+      `#
+      `# Extracted #{Time.now}
+      `# Project.rb Test Extraction
+      `#
+      `
+      `#{reqf}
+      `
+    HERE
+    teststr << testing << "\n"
+    teststr
+  end
+
+end # class Project
+
+
+=begin
+  # Files and file patterns of the test scripts to run.
+  attr_accessor :tests
+  alias_method :files, :tests
+  alias_method :files=, :tests=
+
+  # Prerequisite libraries to require before running tests.
+  attr_accessor :reqs
+  alias_method :require, :reqs
+  alias_method :require=, :reqs=
+
+  # Prerequisite additions to the $LOAD_PATH.
+  attr_accessor :libs
+  alias_method :libpath, :libs
+  alias_method :libpath=, :libs=
+
+  # Run from live installation instead of from the project.
+  attr_accessor :live
+
+  # Test result output format (tim pease)
+  #attr_accessor :style
+
+  # Extract embedded unit tests?
+  attr_accessor :extract
+
+  # Files to check syntax.
+  attr_accessor :scripts
+
+  # New testing tasks.
+  def initialize
+    yield self if block_given?
+
+    @tests   ||= DEFAULT_TEST_FILES
+    @reqs    ||= []
+    @libs    ||= []
+    @live    ||= false
+    @extract ||= false
+
+    define
+  end
+=end