micron 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29d7b92b84fd3c8da1f0d4c41f008153d8074f69
+  data.tar.gz: f76f16a5f3b5e8dbee5ee3b00a7624b72b8fb199
+SHA512:
+  metadata.gz: e10e61aee8e0677d2b4bcecc29c4714b909164821ac630d9e54cc80041c49e87dc78332f39b48b6d77a0dcf9579f80bd081061dc0276d8f9022dd21ba27af5de
+  data.tar.gz: 4bc4917b3ddb759ccb2f5dde09b7898ac5bf788c310554a3e0335eba6e237c6c4fd986876baada9d0e5295e78bc9c762f4832069fa16033fdb5bbb20469310dd

data/Gemfile

@@ -0,0 +1,19 @@
+source "https://rubygems.org"
+
+group :local do
+  gem "micron", :path => "."
+end
+
+gem "easycov", :github => "chetan/easycov"
+
+gem "hitimes"
+gem "colorize"
+
+group :development do
+  gem "yard", "~> 0.8"
+  gem "bundler", "~> 1.1"
+  gem "jeweler", :git => "https://github.com/chetan/jeweler.git", :branch => "bixby"
+
+  gem "minitest",     "~> 4.0", :platforms => [:mri_19, :mri_20, :rbx]
+end
+

data/Gemfile.lock

@@ -0,0 +1,88 @@
+GIT
+  remote: git://github.com/chetan/easycov.git
+  revision: 58be40eddda14fb8db4f1b72427922e8054bae7a
+  specs:
+    easycov (0.1.1)
+      multi_json
+      simplecov
+
+GIT
+  remote: https://github.com/chetan/jeweler.git
+  revision: c83ba18b074e82415052e80499a770bff87bf944
+  branch: bixby
+  specs:
+    jeweler (1.8.7)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+
+PATH
+  remote: .
+  specs:
+    micron (0.5.0)
+      colorize
+      easycov
+      hitimes
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    builder (3.2.2)
+    colorize (0.6.0)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.19)
+    hitimes (1.2.1)
+    httpauth (0.2.0)
+    json (1.8.0)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    minitest (4.7.5)
+    multi_json (1.8.0)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.0)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    yard (0.8.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.1)
+  colorize
+  easycov!
+  hitimes
+  jeweler!
+  micron!
+  minitest (~> 4.0)
+  yard (~> 0.8)

data/Rakefile

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gemspec|
+  gemspec.name = "micron"
+  gemspec.summary = "Minimal unit tests for Ruby"
+  gemspec.description = "An extremely minimal unit test library for Ruby"
+  gemspec.email = "chetan@pixelcop.net"
+  gemspec.homepage = "http://github.com/chetan/micron"
+  gemspec.authors = ["Chetan Sarva"]
+  gemspec.license = "MIT"
+  gemspec.executables = ["micron"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new
+

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/bin/micron

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "micron/app"
+Micron::App.new.run

data/lib/micron.rb

@@ -0,0 +1,29 @@
+
+require "easycov"
+
+require "micron/util/io"
+require "micron/util/thread_dump"
+require "micron/util/ex"
+
+require "micron/assertion"
+require "micron/test_case"
+require "micron/runner"
+
+module Micron
+
+  extend Micron::Util::IO
+  extend Micron::Util::ThreadDump
+  extend Micron::Util::Ex
+
+  class << self
+
+    attr_accessor :backtrace_filter, :runner
+
+    def filter_backtrace(bt)
+      backtrace_filter.call(bt)
+    end
+
+  end # self
+  self.backtrace_filter = BacktraceFilter.new # default filter
+
+end

data/lib/micron/app.rb

@@ -0,0 +1,127 @@
+
+require "micron"
+require "micron/app/options"
+
+require "fileutils"
+
+module Micron
+  class App
+
+    def run(options=nil)
+      $0 = "micron: runner"
+      Thread.current[:name] = "main thread"
+
+      STDOUT.sync = true
+      STDERR.sync = true
+      Micron.trap_thread_dump()
+      Micron::Runner::Shim.setup
+
+      options = Options.parse(options)
+
+      ENV["PARALLEL_EASYCOV"] = "1"
+      if !options[:coverage] then
+        ENV["DISABLE_EASYCOV"] = "1"
+      end
+
+      # Setup paths
+      # TODO allow setting path/root some other way
+      path = options.delete(:path)
+      path = File.expand_path(Dir.pwd)
+      ENV["MICRON_PATH"] = File.join(path, ".micron")
+      FileUtils.mkdir_p(ENV["MICRON_PATH"])
+
+      test_paths = []
+      %w{test .test}.each do |t|
+        t = File.join(path, t)
+        if File.directory?(t) then
+          $: << t
+          test_paths << t
+        end
+      end
+
+      # Setup reporters
+      reporters = []
+      reporters << Reporter::Console.new
+
+      # Spawn child runner if called
+      if options[:runclass] then
+        require "micron/proc_runner"
+        Micron.runner = Micron::ProcRunner.new(nil, reporters)
+        Micron.runner.run_class
+        exit
+      elsif options[:runmethod] then
+        require "micron/proc_runner"
+        Micron.runner = Micron::ProcRunner.new(nil, reporters)
+        Micron.runner.run_method
+        exit
+      end
+
+      # Add coverage reporter
+      if options[:coverage] then
+        reporters.unshift Reporter::Coverage.new
+      end
+
+      # Find tests to run
+      files = []
+      if not ARGV.empty? then
+        ARGV.each do |f|
+          if File.file? f then
+            files << File.expand_path(f)
+          elsif File.directory? f then
+            files += find_tests(File.expand_path(f))
+          end
+        end
+      end
+      files.flatten!
+
+      if files.empty? then
+        files = []
+        test_paths.each{ |t| files += find_tests(t) }
+      end
+
+      files.sort!
+
+      # Run tests
+      if options[:proc] then
+        require "micron/proc_runner"
+        Micron.runner = Micron::ProcRunner.new(files, reporters)
+      elsif options[:fork] then
+        require "micron/fork_runner"
+        Micron.runner = Micron::ForkRunner.new(files, reporters)
+      else
+        Micron.runner = Micron::Runner.new(files, reporters)
+      end
+      results = Micron.runner.run
+
+      Micron::Runner::Shim.cleanup!
+
+      exit(count_failures(results) > 0 ? 1 : 0)
+    end
+
+
+    private
+
+    def find_tests(path)
+      Dir.glob(File.join(path, "**/*.rb")).find_all { |f|
+        f = File.basename(f)
+        f =~ /^(test_.*|.*_test)\.rb$/
+      }
+    end
+
+    # Count the number of failures in the list of results
+    #
+    # @param [Array<Clazz>] results
+    #
+    # @return [Fixnum]
+    def count_failures(results)
+      fail = 0
+      results.each { |c|
+        c.methods.each { |m|
+          fail += 1 if !m.skipped? && !m.passed?
+        }
+      }
+      return fail
+    end
+
+  end
+end

data/lib/micron/app/options.rb

@@ -0,0 +1,73 @@
+
+require 'optparse'
+
+module Micron
+  class App
+    class Options
+
+      DEFAULTS = {
+        :coverage => true
+      }
+
+      def self.parse(options=nil)
+
+        # always try to use default options first
+        if options then
+          options = DEFAULTS.merge(options)
+        else
+          options = DEFAULTS.dup
+        end
+
+        # then rc file
+        rc = File.join(Dir.pwd, ".micronrc")
+        if File.exists? rc then
+          parse_opts(options, File.read(rc).split(" "))
+        end
+
+        # then anything on command line
+        parse_opts(options, ARGV)
+
+        return options
+      end
+
+      def self.parse_opts(options, argv)
+        parser = OptionParser.new do |opts|
+          opts.banner = "usage: #{$0} [options]"
+
+          opts.on("--nocov", "Disable coverage reporting") {
+            options[:coverage] = false
+          }
+
+          opts.on("--proc", "Use the process runner") {
+            options[:proc] = true
+          }
+
+          opts.on("--fork", "Use the forking runner") {
+            options[:fork] = true
+          }
+
+          opts.on("--runclass", "Run class in child process") {
+            options[:runclass] = true
+          }
+
+          opts.on("--runmethod", "Run method in child process") {
+            options[:runmethod] = true
+          }
+        end
+
+        begin
+          parser.parse!(argv)
+
+        rescue Exception => ex
+          exit if ex.kind_of? SystemExit
+          STDERR.puts "error: #{ex}"
+          STDERR.puts
+          STDERR.puts parser
+          exit 1
+        end
+
+        return options
+      end # self.parse_opts
+    end
+  end
+end

data/lib/micron/assertion.rb

@@ -0,0 +1,10 @@
+
+module Micron
+
+  class Assertion < Exception
+  end
+
+  class Skip < Assertion
+  end
+
+end

data/lib/micron/fork_runner.rb

@@ -0,0 +1,55 @@
+
+require "micron/runner/parallel_clazz"
+require "micron/runner/fork_worker"
+require "micron/runner/forking_clazz"
+require "micron/test_case/teardown_coverage"
+
+module Micron
+  class ForkRunner < Runner
+
+    def run
+      report(:start_tests, @files)
+
+      @files.each do |file|
+
+        # fork for each file
+        worker = ForkWorker.new(nil, false) {
+          $0 = "micron: class"
+          # ERR.puts "micron: class (#{$$})"
+
+          test_file = TestFile.new(file)
+          report(:start_file, test_file)
+
+          begin
+            test_file.collect_coverage()
+            test_file.load()
+            results = test_file.run(ForkingClazz)
+          rescue Exception => ex
+            results = [ex]
+          end
+
+          results
+        }.run
+
+        results = worker.wait.result
+        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
+
+      report(:end_tests, @files, @results)
+
+      return @results
+    end
+
+  end # ForkRunner
+end # Micron