micro_test 0.2.8 → 0.3.0

data/README.md

@@ -2,48 +2,101 @@
 
 ## The Sinatra of testing frameworks
 
-### Quick Start
+Testing frameworks often lose their focus and become an end unto themselves.
+MicroTest avoids this pitfall with a relentless focus on simplicity.
 
-Install
+### Here's what MicroTest brings to the table
 
-```bash
-$ gem install micro_test
-```
+* A simple test API/interface
+* An awesome test + dev workflow using Pry
+* Fast asynchronous test runs with Celluloid
 
-Experiment
+## The Interface
 
-```bash
-$ mt --demo
-$ mt --help
-```
+Everything you need to know about MicroTest's API is outlined here.
+
+Its simple by design.
+
+<table>
+  <tr>
+    <td><strong><code>MicroTest::Test</code></strong></td>
+    <td>Superclass for all test classes.</td>
+  </tr>
+  <tr>
+    <td><strong><code>test(desc, &block)</code></strong></td>
+    <td>
+      Defines a test method.
+      <ul>
+        <li><sr<code>desc</code> - a description of what is being tested</li>
+        <li><code>block</code> - a block of code which defines the test</li>
+      </ul>
+    </td>
+  </tr>
+  <tr>
+    <td><strong><code>assert(value)</code></strong></td>
+    <td>
+      Verifies the truthiness of a value.
+      <ul>
+        <li><code>value</code> - the value to assert</li>
+      </ul>
+    </td>
+  </tr>
+  <tr>
+    <td><strong><code>before(&block)</code></strong></td>
+    <td>
+      A callback that runs before each test method.
+      <ul>
+        <li><code>&block</code> - the block of code to execute</li>
+      </ul>
+    </td>
+  </tr>
+  <tr>
+    <td><strong><code>after(&block)</code></strong></td>
+    <td>
+      A callback that runs after each test method.
+      <ul>
+        <li><code>&block</code> - the block of code to execute</li>
+      </ul>
+    </td>
+  </tr>
+</table>
 
-Write
+## A Full Example
+
+The entire public interface is used in this basic example.
 
 ```ruby
-require 'micro_test'
+class MathTest < MicroTest::Test
+
+  before do
+    # runs before each test method
+  end
+
+  after do
+    # runs after each test method
+  end
 
-class MyTest < MicroTest::Test
-  test "some assumption" do
-    assert true
+  test "basic addition" do
+    assert 2 + 2 == 4
   end
+
 end
 ```
 
-Run
+## Get Started
 
-```bash
-$ mt
-```
+MicroTest ships with a demo so you can kick the tires.
 
-Want BDD?
+* Install `$ gem install micro_test`
+* Help `$ mt --help`
+* Demo `$ mt --demo`
 
-```ruby
-class DescribeMyObject < MicroTest::Test
-  test "that a feature does something" do
-    assert true
-  end
-end
-```
+Try some of the more advanced features.
+
+* Pry workflow `$ mt --demo --pry`
+* Async test run `$ mt --demo --async`
 
+MicroTest is small & unobtrusive. It can run parallel with other test frameworks,
+and can be introduced to existing projects with minimal effort.
 
-[See the product page for more details.](http://hopsoft.github.com/micro_test/)
+Start testing today!

data/bin/mt

@@ -1,26 +1,83 @@
 #!/usr/bin/env ruby
-require "rubygems"
-require "slop"
+require "optparse"
+
 lib_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
 require File.join(lib_path, "micro_test")
-require File.join(lib_path, "micro_test", "color")
-
 include MicroTest::Color
 
-opts = Slop.parse(:strict => true, :help => true) do
-  formatters = Dir[File.join(lib_path, "micro_test", "formatters", "*.rb")].map {|f| f[f.rindex("/") + 1..-4]}
-  banner "mt [options]"
-  on :p, :path, "The path to the test directory or file.", :argument => true
-  on :f, :formatter, "The name of the formatter to use. [#{green formatters.join(", ")}]", :argument => true
-  on "fail-fast", "Stops the running of tests after the first test failure."
-  on :pry, "Starts a pry session whenever tests fail."
-  on :demo, "Runs the MicroTest test suite."
+# setup the formatters list ---------------------------------------------------
+formatters_path = File.join(lib_path, "micro_test", "formatters")
+formatter_names = Dir[File.join(formatters_path, "*.rb")].reduce([]) do |memo, file|
+  if (file =~ /(base_formatter\.rb|_async\.rb)$/).nil?
+    name = file[file.rindex("/") + 1..-4]
+    name = name.prepend("*") if name == "mt"
+    memo << name
+  end
+  memo
 end
 
-exit if opts[:help]
+# setup the options -----------------------------------------------------------
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "MicroTest Usage: mt [options] /path/to/test/dir_or_file"
+
+  desc = "Runs tests asynchronously."
+  opts.on("-a", "--async", desc) { |value| options[:async] = value }
+
+  desc = "Runs the MicroTest test suite and some additional demo tests."
+  opts.on("--demo", desc) { |value| options[:demo] = value }
+
+  desc = "The formatter to use. [#{formatter_names.join(", ")}]"
+  opts.on("-f", "--formatter [FORMATTER]", desc) do |value|
+    options[:formatter] = value
+  end
+
+  desc = "Stops the test run after the first failure. "
+  opts.on("--fail-fast", desc) { |value| options[:fail_fast] = value }
+
+  desc = "Starts a PRY session whenever a test fails. "
+  opts.on("--pry", desc) { |value| options[:pry] = value }
+
+  opts.on("-v", "--version", "Show version.") do
+    puts "MicroTest #{MicroTest::VERSION}"
+    exit
+  end
+
+  opts.on_tail("-h", "--help", "Show this message.") do
+    puts opts
+    exit
+  end
+
+end
+parser.parse!
 
-path = opts[:path] || "test"
-path = File.expand_path(File.join(File.dirname(__FILE__), "..", "test")) if opts[:demo]
+# apply rules to the options --------------------------------------------------
+if RUBY_ENGINE == "jruby"
+  if options[:pry]
+    options[:pry] = nil
+    puts red("Unfortunately the pry option is not available on jruby")
+    puts red("due to a dependency on pry-stack_explorer & binding_of_caller.")
+    puts "However, the pry workflow is awesome. Switch to #{green "mri 1.9"} to try it."
+  end
+end
+if RUBY_ENGINE == "rbx"
+  if options[:pry]
+    options[:pry] = nil
+    puts red("Unfortunately the pry option is not available on rubinius at this time")
+    puts red("due to weird behavior related to pry & pry-stack_explorer.")
+    puts "However, the pry workflow is awesome. Switch to #{green "mri 1.9"} to try it."
+  end
+end
+if options[:async] && options[:pry]
+  options[:pry] = nil
+  puts red("Disabling pry while runing in async mode to avoid interleaved pry session chaos.")
+end
+ENV["MT_DEMO"] = "true" if options[:demo]
+
+# setup the test path ---------------------------------------------------------
+path = ARGV.last unless ARGV.last =~ /^-/
+path = File.expand_path(File.join(File.dirname(__FILE__), "..", "test")) if options[:demo]
+path ||= "test"
 path = File.join(Dir.pwd, path) unless path =~ /^\//
 unless File.exist?(path)
   puts "#{path} not found."
@@ -30,52 +87,56 @@ end
 if path =~ /\.rb$/
   require path
 else
-  Dir[File.join(path, "**", "*.rb")].each do |p|
-    require p unless p =~ /fail\.rb$/ && opts[:demo].nil?
-  end
+  Dir[File.join(path, "**", "*.rb")].each { |path| require path }
 end
 
-formatter_name = opts[:formatter] || "default"
-formatter_name = "documentation" if formatter_name == "d"
-formatter_path = File.join(lib_path, "micro_test", "formatters", formatter_name + ".rb")
-unless File.exist?(formatter_path)
-  puts "#{formatter_path} not found."
+# setup the formatter ---------------------------------------------------------
+formatter_name = options[:formatter] || "mt"
+path = File.join(formatters_path, formatter_name + ".rb")
+if options[:async]
+  async_path = path.gsub(/\.rb$/, "_async.rb")
+  path = async_path if File.exist?(async_path)
+end
+unless File.exist?(path)
+  puts "Formatter not found at #{path}"
   puts "Please check the formatter name and try again."
   exit
 end
 begin
-  require formatter_path
+  require path
   formatter = MicroTest.const_get("Formatter").new
 rescue Exception => ex
-  puts "Failed to load the formatter."
+  puts "Failed to load the formatter defined at #{path}"
   puts ex.message
   exit
 end
 
-MicroTest::Test.add_observer(Class.new do
-  def self.update(event, arg)
-    if event == :assert && !arg
-      binding.pry(:quiet => true) if MicroTest::Runner.options[:pry]
-      exit if MicroTest::Runner.options[:"fail-fast"]
-    end
-  end
-end)
+# setup the test runner -------------------------------------------------------
+runner = MicroTest::Runner.new(formatter, options)
+
+# setup pry -------------------------------------------------------------------
+if options[:pry]
 
-if opts[:pry]
-  require "pry"
-  require "pry-stack_explorer"
+  begin
+    require "pry"
+    require "pry-stack_explorer"
+  rescue Exception => e
+    puts red("Unable to require pry or pry-stack_explorer!")
+    puts yellow("Be sure to add these gems to your Gemfile and bundle if you are using Bundler.")
+    exit
+  end
 
   Pry.config.hooks.add_hook :before_session, :print_instructions do |_, _, _pry_|
     _pry_.commands.create_command "line", "View the assert line that failed." do
       def process
-        _pry_.run_command "up 5"
+        _pry_.run_command "up 1"
       end
     end
 
     puts
     puts "".ljust(80, "-")
     puts
-    puts red " " + MicroTest::Runner.current_test
+    puts red " " + runner.active_test.desc
     puts
     puts "".ljust(80, "-")
     puts " Pry session started"
@@ -90,6 +151,4 @@ if opts[:pry]
   end
 end
 
-@start = Time.now
-MicroTest::Runner.run formatter, opts.to_hash
-puts "Completed in #{Time.now - @start} seconds."
+runner.run

data/ext/mkrf_conf.rb

@@ -0,0 +1,32 @@
+# based on instructions here:
+# http://en.wikibooks.org/wiki/Ruby_Programming/RubyGems#How_to_install_different_versions_of_gems_depending_on_which_version_of_ruby_the_installee_is_using
+require 'rubygems'
+require 'rubygems/command.rb'
+require 'rubygems/dependency_installer.rb'
+
+begin
+  Gem::Command.build_args = ARGV
+  rescue NoMethodError
+end
+
+installer = Gem::DependencyInstaller.new
+
+begin
+  if RUBY_ENGINE != "jruby"
+    puts "Installing pry and pry-stack_explorer."
+    installer.install "pry"
+    installer.install "pry-stack_explorer"
+  else
+    puts "Platform is java... skip install for pry and pry-stack_explorer."
+  end
+rescue Exception => e
+  puts e.message
+  puts e.backtrace.join("\n")
+  exit(1)
+end
+
+f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w")   # create dummy rakefile to indicate success
+f.write("task :default\n")
+f.close
+
+exit

data/lib/micro_test/formatters/base_formatter.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), "..", "color")
+
+module MicroTest
+
+  # The base class for formatters.
+  # Defines the API that formatters can/should implement
+  # to control test run output.
+  class BaseFormatter
+    include MicroTest::Color
+    attr_accessor :passed, :failed, :duration
+
+    def initialize
+      @duration = 0
+      @passed = 0
+      @failed = 0
+    end
+
+    def before_suite(test_classes)
+    end
+
+    def before_class(test_class)
+    end
+
+    def before_test(test)
+    end
+
+    def after_test(test)
+    end
+
+    def after_class(test_class)
+    end
+
+    def after_results(runner)
+      @duration = runner.duration
+      @passed = runner.passed
+      @failed = runner.failed
+    end
+
+    def after_suite(test_classes)
+    end
+
+  end
+end

data/lib/micro_test/formatters/doc.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), "base_formatter")
+
+module MicroTest
+  class Formatter < MicroTest::BaseFormatter
+
+    def initialize
+      @failures = []
+    end
+
+    def before_class(test_class)
+      puts "\n#{test_class.name}"
+    end
+
+    def after_test(test)
+      super
+      if test.passed?
+        puts green("  #{test.desc}")
+      else
+        test.asserts.each do |assert|
+          next if assert[:value]
+          @failures << { :test => test, :assert => assert }
+          puts red("  #{test.desc}")
+        end
+      end
+    end
+
+    def print_failures(failures)
+      puts
+      puts "Failures:"
+      puts
+      failures.each_with_index do |failure, idx|
+        test = failure[:test]
+        assert = failure[:assert]
+        puts
+        puts "  #{idx + 1}) #{test.test_class.name} #{test.desc}"
+        puts red("     Failure/Error: #{assert[:line].strip}")
+        puts cyan("     #{assert[:file_path]}:#{assert[:line_num]}")
+      end
+    end
+
+    def after_suite(test_classes)
+      print_failures(@failures) if failed > 0
+      puts
+      msg = "#{passed + failed} examples, #{failed} failures"
+      if failed > 0
+        puts red(msg)
+      else
+        puts msg
+      end
+      puts
+      super
+    end
+
+  end
+end

data/lib/micro_test/formatters/dots.rb

@@ -1,27 +1,16 @@
-require File.join(File.dirname(__FILE__), "..", "color")
+require File.join(File.dirname(__FILE__), "base_formatter")
 
 module MicroTest
-  class Formatter
-    include MicroTest::Color
+  class Formatter < MicroTest::BaseFormatter
 
-    def initialize
+    def after_test(test)
+      print(test.passed? ? green(".") : red("."))
     end
 
-    def header
-    end
-
-    def group(name)
-    end
-
-    def test(info)
-      if info[:passed]
-        print green(".")
-      else
-        print red("x")
-      end
-    end
-
-    def footer
+    def after_suite(test_classes)
+      puts
+      puts "".ljust(80, "-")
+      puts "Finished in #{duration} seconds."
       puts
     end
 

data/lib/micro_test/formatters/min.rb

@@ -1,26 +1,15 @@
-require File.join(File.dirname(__FILE__), "..", "color")
+require File.join(File.dirname(__FILE__), "base_formatter")
 
 module MicroTest
-  class Formatter
-    include MicroTest::Color
+  class Formatter < MicroTest::BaseFormatter
 
-    def initialize
-      @passed = 0
-      @failed = 0
-    end
-
-    def header
-    end
-
-    def group(name)
-    end
-
-    def test(info)
-      info[:passed] ? @passed += 1 : @failed += 1
-    end
-
-    def footer
-      puts "Passed: #{green @passed}, Failed: #{red @failed}"
+    def after_suite(test_classes)
+      puts
+      puts "Passed: #{green passed}"
+      puts "Failed: #{red failed}"
+      puts "".ljust(80, "-")
+      puts "Finished in #{duration} seconds."
+      puts
     end
 
   end

data/lib/micro_test/formatters/mt.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), "base_formatter")
+
+module MicroTest
+  class Formatter < MicroTest::BaseFormatter
+    def before_class(test_class)
+      puts
+      puts test_class.name.ljust(80, "-")
+    end
+
+    def after_test(test)
+      duration = (test.duration * 10**4).round.to_f / 10**4
+      if duration < 0.01
+        print yellow("  #{duration.to_s.ljust(6, "0")}")
+      else
+        print red("  #{duration.to_s.ljust(6, "0")}")
+      end
+
+      if test.passed?
+        print green(" #{test.desc}")
+      else
+        puts red(" #{test.desc}")
+        test.failed_asserts.each do |assert|
+          puts
+          print "".ljust(9)
+          puts "#{assert[:file_path]}:#{red(assert[:line_num])}"
+          puts "".ljust(9) + "".rjust(71, "-")
+          index = assert[:line_num] - 1
+          start = index - 2
+          start = 0 if start <= 0
+          finish = index + 2
+          finish = assert[:lines].length - 1 if finish >= assert[:lines].length
+          (start..finish).each do |i|
+            print "".ljust(9)
+            if i == index
+              print red((i + 1).to_s.rjust(3, "0"))
+              print red("|")
+              print red(assert[:lines][i])
+            else
+              print (i + 1).to_s.rjust(3, "0")
+              print "|"
+              print assert[:lines][i]
+            end
+          end
+        end
+      end
+
+      puts
+    end
+
+    def after_suite(test_classes)
+      puts
+      puts "".ljust(80, "-")
+      print " #{passed + failed} Tests finished in #{yellow duration} seconds. "
+      totals = []
+      totals << green("#{passed} Passed") if passed > 0
+      totals << red("#{failed} Failed") if failed > 0
+      print "(#{totals.join(", ")})"
+      puts
+      puts
+    end
+
+  end
+end

data/lib/micro_test/formatters/mt_async.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), "base_formatter")
+
+module MicroTest
+  class Formatter < MicroTest::BaseFormatter
+
+    def after_test(test)
+      test.passed? ? print(green ".") : print(red ".")
+    end
+
+    def after_suite(test_classes)
+      puts
+
+      test_classes.each do |test_class|
+        puts
+        puts test_class.name.ljust(80, "-")
+
+        test_class.tests.each do |test|
+          duration = (test.duration * 10**4).round.to_f / 10**4
+          print yellow("  #{duration.to_s.ljust(6, "0")}")
+
+          if test.passed?
+            print green(" #{test.desc}")
+          else
+            puts red(" #{test.desc}")
+            test.failed_asserts.each do |assert|
+              puts
+              print "".ljust(9)
+              puts "#{assert[:file_path]}:#{red(assert[:line_num])}"
+              puts "".ljust(9) + "".rjust(71, "-")
+              index = assert[:line_num] - 1
+              start = index - 2
+              start = 0 if start <= 0
+              finish = index + 2
+              finish = assert[:lines].length - 1 if finish >= assert[:lines].length
+              (start..finish).each do |i|
+                print "".ljust(9)
+                if i == index
+                  print red((i + 1).to_s.rjust(3, "0"))
+                  print red("|")
+                  print red(assert[:lines][i])
+                else
+                  print (i + 1).to_s.rjust(3, "0")
+                  print "|"
+                  print assert[:lines][i]
+                end
+              end
+            end
+          end
+
+          puts
+        end
+      end
+
+      puts
+      puts "".ljust(80, "-")
+      print " #{passed + failed} Tests finished in #{yellow duration} seconds. "
+      totals = []
+      totals << green("#{passed} Passed") if passed > 0
+      totals << red("#{failed} Failed") if failed > 0
+      print "(#{totals.join(", ")})"
+      puts
+      puts
+    end
+
+  end
+end