micron 0.5.0

data/lib/micron/minitest.rb

@@ -0,0 +1,45 @@
+
+# Compatibility layer for MiniTest
+
+require "micron"
+
+old_verbose = $VERBOSE
+$VERBOSE = nil
+
+module MiniTest
+  Assertion = Micron::Assertion
+
+  class Unit
+
+    VERSION = "4.7"
+    TestCase = Micron::TestCase
+
+    def self.autorun
+      # noop
+    end
+
+    class TestCase
+
+      def name
+        self.class.name
+      end
+      alias_method :__name__, :name
+
+      def micron_method=(method)
+        @micron_method = method
+      end
+
+      def passed?
+        @micron_method.passed?
+      end
+
+      def self.parallelize_me!
+        # noop
+      end
+
+    end
+
+  end
+end
+
+$VERBOSE = old_verbose

data/lib/micron/proc_runner.rb

@@ -0,0 +1,114 @@
+
+require "micron/runner/parallel_clazz"
+require "micron/runner/fork_worker"
+require "micron/runner/proc_clazz"
+require "micron/test_case/teardown_coverage"
+
+module Micron
+  class ProcRunner < Runner
+
+    def initialize(files=nil, reporters=nil)
+      super(files, reporters)
+    end
+
+    def run
+      $0 = "micron: proc_runner"
+      # ERR.puts "#{$0} (#{$$})"
+
+      state_path = ENV["MICRON_PATH"]
+      FileUtils.mkdir_p(state_path)
+
+      report(:start_tests, @files)
+      @files.each do |file|
+
+        ENV["MICRON_TEST_FILE"] = file
+        pid = fork do
+          exec("bundle exec micron --runclass")
+        end
+        Process.wait
+
+        # puts "got stdout: #{cmd.stdout}"
+        # puts "got stderr: #{cmd.stderr}"
+        # puts "status: #{cmd.status}"
+        # puts "exitstatus: #{cmd.exitstatus.inspect}"
+
+        data_file = File.join(state_path, "#{pid}.data")
+        File.open(data_file) do |f|
+          while !f.eof
+            clazz = Marshal.load(f) # read Clazz from child via file
+            if clazz.kind_of? Exception then
+              puts "Error loading test file: #{file}"
+              puts clazz
+              puts clazz.backtrace
+              exit 1
+            end
+
+            # should be a Clazz
+            @results << clazz
+          end
+        end
+        File.delete(data_file)
+
+      end
+
+      report(:end_tests, @files, @results)
+
+      return @results
+    end # run
+
+
+    # Child process which runs an entire test file/class
+    def run_class
+      $0 = "micron:proc_run_class"
+      # ERR.puts "micron: proc_run_class (#{$$})"
+
+      test_file = TestFile.new(test_filename)
+      report(:start_file, test_file)
+
+      begin
+        test_file.load(false)
+        results = test_file.run(ProcClazz)
+      rescue Exception => ex
+        results = [ex]
+      end
+
+      # pass data back to parent process
+      data_file = File.join(ENV["MICRON_PATH"], "#{$$}.data")
+      File.open(data_file, "w") do |f|
+        results.each { |r| Marshal.dump(r, f) }
+      end
+    end
+
+    # Child process which runs a single method in a given file & class
+    def run_method
+      $0 = "micron:proc_run_method"
+      # ERR.puts "#{$0} (#{$$})"
+
+      test_clazz = ENV["MICRON_TEST_CLASS"]
+      test_method = ENV["MICRON_TEST_METHOD"]
+
+      # ERR.puts "test_clazz: #{test_clazz}"
+      # ERR.puts "test_method: #{test_method}"
+
+      test_file = TestFile.new(test_filename)
+      test_file.load(true)
+      # load and run a specific method only
+      result = test_file.run_method(test_clazz, test_method, Clazz)
+
+      # pass data back to parent process
+      data_file = File.join(ENV["MICRON_PATH"], "#{$$}.data")
+      File.open(data_file, "w") do |f|
+        Marshal.dump(result, f)
+      end
+    end
+
+
+    private
+
+    def test_filename
+      ENV["MICRON_TEST_FILE"]
+    end
+
+
+  end
+end

data/lib/micron/rake.rb

@@ -0,0 +1,29 @@
+
+module Micron
+  class Rake < ::Rake::TaskLib
+
+
+    def initialize(&block)
+      @config = {
+        :path => File.dirname(ENV["BUNDLE_GEMFILE"])
+      }
+      block.call(@config) if block
+
+      define()
+    end
+
+    private
+
+    def define
+
+      desc "Run micron tests"
+      task :test do
+        require "micron/app"
+        ARGV.clear
+        Micron::App.new.run(@config)
+      end
+
+    end
+
+  end
+end

data/lib/micron/reporter.rb

@@ -0,0 +1,30 @@
+
+module Micron
+  class Reporter
+
+    def start_tests(files)
+    end
+
+    def start_file(test_file)
+    end
+
+    def start_class(clazz)
+    end
+
+    def end_method(method)
+    end
+
+    def end_class(clazz)
+    end
+
+    def end_file(test_file)
+    end
+
+    def end_tests(files, results)
+    end
+
+  end
+end
+
+require "micron/reporter/console"
+require "micron/reporter/coverage"

data/lib/micron/reporter/console.rb

@@ -0,0 +1,146 @@
+
+require "colorize"
+
+module Micron
+  class Reporter
+    class Console < Reporter
+
+      CONSOLE_WIDTH = 100
+
+      def start_tests(files)
+        @runtime = Hitimes::Interval.now
+        puts "="*CONSOLE_WIDTH
+        puts ralign("START TESTS (#{files.size} files)", "#{Time.new}")
+        puts "="*CONSOLE_WIDTH
+        puts
+      end
+
+      def start_class(clazz)
+        puts clazz.name
+      end
+
+      def end_method(m)
+        name = m.name.to_s
+        duration = sprintf("%0.3f", m.total_duration)
+
+        status = m.status.upcase
+
+        str = ralign(indent(name), "#{duration} #{status}")
+
+        # inject color after so we don't screw up the alignment
+        if m.skipped? then
+          str.gsub!(/#{status}$/, status.colorize(:light_yellow))
+        elsif m.passed? then
+          str.gsub!(/#{status}$/, status.colorize(:light_green))
+        else
+          str.gsub!(/#{status}$/, status.colorize(:light_red))
+        end
+        puts str
+
+        if m.failed? and !m.skipped? then
+
+          puts
+          puts indent(underline("Exception:"))
+          if m.ex.kind_of? Array then
+            m.ex.each{ |ex|
+              next if m.ex.nil?
+              puts indent(Micron.dump_ex(ex, true))
+              puts
+            }
+          elsif m.ex.nil? then
+            puts indent("nil")
+            puts
+          else
+            puts indent(Micron.dump_ex(m.ex, true))
+            puts
+          end
+
+          if not m.stdout.empty? then
+            puts indent(underline("STDOUT:"))
+            puts indent(m.stdout.rstrip)
+            puts
+          end
+
+          if not m.stderr.empty? then
+            puts indent(underline("STDERR:"))
+            puts indent(m.stderr.rstrip)
+            puts
+          end
+
+        end
+      end
+
+      def end_class(clazz)
+        puts
+      end
+
+      def end_tests(files, results)
+
+        @runtime.stop
+
+        total = pass = fail = skip = 0
+        total_duration = 0.0
+        total_assertions = 0
+
+        results.each { |c|
+          c.methods.each { |m|
+            total += 1
+            total_duration += m.total_duration
+            total_assertions += m.assertions
+            if m.skipped? then
+              skip += 1
+            elsif m.passed? then
+              pass += 1
+            else
+              fail += 1
+            end
+          }
+        }
+
+        total_duration = sprintf("%0.3f", total_duration)
+        real_runtime = sprintf("%0.3f", @runtime.duration)
+
+        puts
+        puts ("="*CONSOLE_WIDTH).colorize((fail > 0 ? :light_red : :light_green))
+        puts "  PASS: #{pass},  FAIL: #{fail},  SKIP: #{skip}"
+        puts "  TOTAL: #{total} with #{total_assertions} assertions in #{total_duration} seconds (wall time: #{real_runtime})"
+
+        if fail > 0 then
+          puts
+          puts "  Failed tests:"
+          results.each { |c|
+            c.methods.each { |m|
+              if !m.skipped? and m.failed? then
+                puts "    #{c.name}##{m.name}"
+              end
+            }
+          }
+        end
+        puts ("="*CONSOLE_WIDTH).colorize((fail > 0 ? :light_red : :light_green))
+      end
+
+
+      private
+
+      # Right align 'b' with padding after a
+      #
+      # e.g.:
+      # a <padding> b
+      def ralign(a, b, length=CONSOLE_WIDTH)
+        p = length-a.length-b.length
+        a + (" "*p) + b
+      end
+
+      # Indent the string by the given amount
+      def indent(str, amount=2)
+        i = (" "*amount)
+        (i + str.gsub(/\n/, "\n#{i}")).rstrip
+      end
+
+      def underline(str)
+        str += "\n" + "-"*str.length
+      end
+
+    end
+  end
+end

data/lib/micron/reporter/coverage.rb

@@ -0,0 +1,37 @@
+
+module Micron
+  class Reporter
+
+    # Reporter which generates coverage report using SimpleCov
+    class Coverage < Reporter
+
+      def end_tests(files, results)
+        generate_coverage_report()
+      end
+
+
+      private
+
+      def generate_coverage_report
+        path = File.dirname(ENV["MICRON_PATH"])
+
+        # Locate easycov path used in tests
+        %w{coverage .coverage}.each do |t|
+          t = File.join(path, t)
+          if File.directory?(t) && !Dir.glob(File.join(t, ".tmp.*.resultset.json")).empty? then
+            EasyCov.path = t
+          end
+        end
+
+        # Merge coverage
+        EasyCov.merge!
+
+        # Write coverage
+        Micron.capture_io {
+          SimpleCov::ResultMerger.merged_result.format!
+        }
+      end
+
+    end
+  end
+end

data/lib/micron/runner.rb

@@ -0,0 +1,95 @@
+
+require "micron/runner/shim"
+
+require "micron/runner/backtrace_filter"
+require "micron/runner/debug"
+
+require "micron/runner/test_file"
+require "micron/runner/clazz"
+require "micron/runner/method"
+require "micron/runner/exception_info"
+
+require "micron/reporter"
+
+module Micron
+
+  # Default Runner - forks for each file
+  class Runner
+
+    OUT = $stdout
+    ERR = $stderr
+
+    # these exceptions, if caught while running, will be re-raised
+    PASSTHROUGH_EXCEPTIONS = [
+      NoMemoryError, SignalException, Interrupt, SystemExit
+    ]
+
+    attr_reader :results
+
+    def initialize(files, reporters)
+      @files     = files
+      @results   = []
+      @reporters = reporters || []
+
+      @mutex = Mutex.new
+
+      if self.class.to_s != "Micron::Runner" then
+        # Only needed in fork/proc runners
+        TestCase.class_eval do
+          include TestCase::TeardownCoverage
+        end
+      end
+    end
+
+    def run
+      report(:start_tests, @files)
+
+      @files.each do |file|
+
+        test_file = TestFile.new(file)
+        report(:start_file, test_file)
+
+        begin
+          test_file.load(true)
+          results = test_file.run(Clazz)
+        rescue Exception => ex
+          results = [ex]
+        end
+
+        results.each do |clazz|
+          if clazz.kind_of? Exception then
+            puts "Error loading test file: #{file}"
+            puts clazz
+            puts clazz.backtrace
+            exit 1
+          end
+
+          # should be a Clazz
+          @results << clazz
+        end
+
+      end
+
+      EasyCov.dump
+      report(:end_tests, @files, @results)
+
+      return @results
+    end
+
+    # Fire the given report event on all reporters
+    #
+    # @param [Symbol] method
+    # @param [*args]
+    def report(method, *args)
+      synchronize {
+        @reporters.each { |r| r.send(method, *args) }
+      }
+    end
+
+    # Output synchronization helper. Will NOT work across forks!
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+
+  end # Runner
+end # Micron