journo 0.2.0

data/.gitignore

@@ -0,0 +1,22 @@
+coverage
+rdoc
+pkg
+test/tmp
+test/version_tmp
+tmp
+pkg
+*.gem
+*.rbc
+lib/bundler/man
+spec/reports
+.config
+InstalledFiles
+.bundle
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# Gem-specific
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,7 @@
+script: 'rake test'
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx
+  - jruby

data/.yardopts

@@ -0,0 +1,6 @@
+--readme          README.md
+--markup          markdown
+--markup-provider maruku
+--default-return  ""
+--title           "Minitest-reporter Documentation"
+--hide-void-return

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Alexander Kern
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# journo - reporters for MiniTest [![StillMaintained Status](http://stillmaintained.com/CapnKernul/journo.png)](http://stillmaintained.com/CapnKernul/journo) [![Build Status](http://travis-ci.org/CapnKernul/journo.png)](http://travis-ci.org/CapnKernul/journo) #
+
+Allows you to extend MiniTest using reporters rather than monkey-patching.
+
+## Installation ##
+
+    gem install journo
+
+## Usage ##
+
+In your `test_helper.rb` file, add the following lines:
+
+    require 'journo'
+    MiniTest::Unit.runner = Journo::SuiteRunner.new
+    MiniTest::Unit.runner.reporters << Journo::Reporters::ProgressReporter.new
+
+Now, just run your tests; the reporter you specified will be used and make your
+output look absolutely gorgeous! If you feel the need to write your own
+reporter, just subclass `Journo::Reporter` and override the methods you'd
+like. Take a look at the provided reporters for examples.
+
+The following reporters are provided:
+
+    Journo::Reporters::DefaultReporter # => Identical to the standard MiniTest reporter
+    Journo::Reporters::SpecReporter # => Turn-like output that reads like a spec
+    Journo::Reporters::ProgressReporter # => Fuubar-like output with a progress bar
+
+I really like `ProgressReporter`.
+
+## Note on Patches/Pull Requests ##
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, but do not mess with the `Rakefile`. If you want to have your own version, that is fine but bump the version in a commit by itself in another branch so I can ignore it when I pull.
+* Send me a pull request. Bonus points for git flow feature branches.
+
+## Resources ##
+
+* [GitHub Repository](https://github.com/CapnKernul/journo)
+* [Documentation](http://rubydoc.info/github/CapnKernul/journo)
+
+## License ##
+
+Journo is licensed under the MIT License. See `LICENSE` for details.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.ruby_opts += ['-rubygems']
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end

data/journo.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'journo/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'journo'
+  s.version     = Journo::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Alexander Kern']
+  s.email       = ['alex@kernul.com']
+  s.homepage    = 'https://github.com/CapnKernul/journo'
+  s.summary     = %q{Reporters for MiniTest}
+  s.description = %q{Allows you to extend MiniTest using reporters rather than monkey-patching}
+  
+  s.rubyforge_project = 'journo'
+  
+  s.add_dependency 'minitest', '~> 2.0'
+  s.add_dependency 'ansi'
+  s.add_dependency 'ruby-progressbar'
+  
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'maruku'
+  s.add_development_dependency 'test_declarative'
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/lib/journo.rb

@@ -0,0 +1,15 @@
+require 'minitest/unit'
+
+module Journo
+  require 'journo/version'
+  
+  autoload :Reporter, 'journo/reporter'
+  autoload :SuiteRunner, 'journo/suite_runner'
+  autoload :TestRunner, 'journo/test_runner'
+  
+  module Reporters
+    autoload :DefaultReporter, 'journo/reporters/default_reporter'
+    autoload :SpecReporter, 'journo/reporters/spec_reporter'
+    autoload :ProgressReporter, 'journo/reporters/progress_reporter'
+  end
+end

data/lib/journo/reporter.rb

@@ -0,0 +1,35 @@
+module Journo
+  class Reporter
+    VERSION = '0.1.0'
+    
+    def runner
+      MiniTest::Unit.runner
+    end
+    
+    def output
+      runner.output
+    end
+    
+    def verbose?
+      runner.verbose
+    end
+    
+    def print(*args)
+      runner.output.print(*args)
+    end
+    
+    def puts(*args)
+      runner.output.puts(*args)
+    end
+    
+    def before_suites(suites, type); end
+    def after_suites(suites, type); end
+    def before_suite(suite); end
+    def after_suite(suite); end
+    def before_test(suite, test); end
+    def pass(suite, test, test_runner); end
+    def skip(suite, test, test_runner); end
+    def failure(suite, test, test_runner); end
+    def error(suite, test, test_runner); end
+  end
+end

data/lib/journo/reporters/default_reporter.rb

@@ -0,0 +1,103 @@
+require 'ansi'
+
+module Journo
+  module Reporters
+    # A reporter identical to the standard MiniTest reporter.
+    # 
+    # Based upon Ryan Davis of Seattle.rb's MiniTest (MIT License).
+    # 
+    # @see https://github.com/seattlerb/minitest MiniTest
+    class DefaultReporter < Journo::Reporter
+      def before_suites(suites, type)
+        puts
+        puts "# Running #{type}s:"
+        puts
+      end
+      
+      def before_test(suite, test)
+        print "#{suite}##{method} = " if verbose?
+      end
+      
+      def pass(suite, test, test_runner)
+        after_test('.')
+      end
+      
+      def skip(suite, test, test_runner)
+        after_test('S')
+      end
+      
+      def failure(suite, test, test_runner)
+        after_test('F')
+      end
+      
+      def error(suite, test, test_runner)
+        after_test('E')
+      end
+      
+      def after_suites(suites, type)
+        time = Time.now - runner.start_time
+        
+        puts
+        puts
+        puts "Finished #{type}s in %.6fs, %.4f tests/s, %.4f assertions/s." %
+          [time, runner.test_count / time, runner.assertion_count / time]
+        
+        i = 0
+        runner.report.each do |suite, tests|
+          tests.each do |test, test_runner|
+            message = message_for(test_runner)
+            if message
+              i += 1
+              puts "\n%3d) %s" % [i, message]
+            end
+          end
+        end
+        
+        puts
+        
+        puts status
+      end
+      
+      private
+      
+      def after_test(result)
+        time = Time.now - runner.test_start_time
+        
+        print '%.2f s = ' % time if verbose?
+        print result
+        puts if verbose?
+      end
+      
+      def location(exception)
+        last_before_assertion = ''
+        
+        exception.backtrace.reverse_each do |s|
+          break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
+          last_before_assertion = s
+        end
+        
+        last_before_assertion.sub(/:in .*$/, '')
+      end
+      
+      def message_for(test_runner)
+        suite = test_runner.suite
+        test = test_runner.test
+        e = test_runner.exception
+        
+        case test_runner.result
+        when :pass then nil
+        when :skip then "Skipped:\n#{test}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
+        when :failure then "Failure:\n#{test}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
+        when :error
+          bt = MiniTest::filter_backtrace(test_runner.exception.backtrace).join "\n    "
+          "Error:\n#{test}(#{suite}):\n#{e.class}: #{e.message}\n    #{bt}\n"
+        end
+      end
+      
+      def status
+        '%d tests, %d assertions, %d failures, %d errors, %d skips' %
+          [runner.test_count, runner.assertion_count, runner.failures, runner.errors, runner.skips]
+      end
+    end
+  end
+end

data/lib/journo/reporters/progress_reporter.rb

@@ -0,0 +1,107 @@
+require 'ansi'
+require 'progressbar'
+
+module Journo
+  module Reporters
+    # Fuubar-like reporter with a progress bar.
+    # 
+    # Based upon Jeff Kreefmeijer's Fuubar (MIT License) and paydro's
+    # monkey-patch.
+    # 
+    # @see https://github.com/jeffkreeftmeijer/fuubar Fuubar
+    # @see https://gist.github.com/356945 paydro's monkey-patch
+    class ProgressReporter < Journo::Reporter
+      include ANSI::Code
+      
+      INFO_PADDING = 2
+      
+      def before_suites(suites, type)
+        puts 'Started'
+        puts
+        
+        @color = GREEN
+        @finished_count = 0
+        @progress = ProgressBar.new("0/#{runner.test_count}", runner.test_count, runner.output)
+        @progress.bar_mark = '='
+      end
+      
+      def increment
+        with_color do
+          @finished_count += 1
+          @progress.instance_variable_set('@title', "#{@finished_count}/#{runner.test_count}")
+          @progress.inc
+        end
+      end
+      
+      def pass(suite, test, test_runner)
+        increment
+      end
+      
+      def skip(suite, test, test_runner)
+        @color = YELLOW unless @color == RED
+        print(yellow { 'SKIP' })
+        print_test_with_time(suite, test)
+        puts
+        puts
+        increment
+      end
+      
+      def failure(suite, test, test_runner)
+        @color = RED
+        print(red { 'FAIL' })
+        print_test_with_time(suite, test)
+        puts
+        print_info(test_runner.exception)
+        puts
+        increment
+      end
+      
+      def error(suite, test, test_runner)
+        @color = RED
+        print(red { 'ERROR' })
+        print_test_with_time(suite, test)
+        puts
+        print_info(test_runner.exception)
+        puts
+        increment
+      end
+      
+      def after_suites(suites, type)
+        with_color { @progress.finish }
+        
+        total_time = Time.now - runner.start_time
+        
+        puts
+        puts('Finished in %.5fs' % total_time)
+        print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
+        print(red { '%d failures, %d errors, ' } % [runner.failures, runner.errors])
+        print(yellow { '%d skips' } % runner.skips)
+        puts
+      end
+      
+      private
+      
+      def print_test_with_time(suite, test)
+        total_time = Time.now - runner.test_start_time
+        print(" #{suite}##{test} (%.2fs)#{clr}" % total_time)
+      end
+      
+      def print_info(e)
+        e.message.each_line { |line| puts pad(line) }
+        
+        trace = MiniTest.filter_backtrace(e.backtrace)
+        trace.each { |line| puts pad(line) }
+      end
+      
+      def pad(str)
+        ' ' * INFO_PADDING + str
+      end
+      
+      def with_color
+        print @color
+        yield
+        print CLEAR
+      end
+    end
+  end
+end

data/lib/journo/reporters/spec_reporter.rb

@@ -0,0 +1,92 @@
+require 'ansi'
+
+module Journo
+  module Reporters
+    # Turn-like reporter that reads like a spec.
+    # 
+    # Based upon TwP's turn (MIT License) and paydro's monkey-patch.
+    # 
+    # @see https://github.com/TwP/turn turn
+    # @see https://gist.github.com/356945 paydro's monkey-patch
+    class SpecReporter < Journo::Reporter
+      include ANSI::Code
+      
+      TEST_PADDING = 2
+      INFO_PADDING = 8
+      MARK_SIZE    = 5
+      
+      def before_suites(suites, type)
+        puts 'Started'
+        puts
+      end
+      
+      def after_suites(suites, type)
+        total_time = Time.now - runner.start_time
+        
+        puts('Finished in %.5fs' % total_time)
+        print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
+        print(red { '%d failures, %d errors, ' } % [runner.failures, runner.errors])
+        print(yellow { '%d skips' } % runner.skips)
+        puts
+      end
+      
+      def before_suite(suite)
+        puts suite
+      end
+      
+      def after_suite(suite)
+        puts
+      end
+      
+      def pass(suite, test, test_runner)
+        print(green { pad_mark('PASS') })
+        print_test_with_time(test)
+        puts
+      end
+      
+      def skip(suite, test, test_runner)
+        print(yellow { pad_mark('SKIP') })
+        print_test_with_time(test)
+        puts
+      end
+      
+      def failure(suite, test, test_runner)
+        print(red { pad_mark('FAIL') })
+        print_test_with_time(test)
+        puts
+        print_info(test_runner.exception)
+        puts
+      end
+      
+      def error(suite, test, test_runner)
+        print(red { pad_mark('ERROR') })
+        print_test_with_time(test)
+        puts
+        print_info(test_runner.exception)
+        puts
+      end
+      
+      private
+      
+      def print_test_with_time(test)
+        total_time = Time.now - runner.test_start_time
+        print(" #{test} (%.2fs)" % total_time)
+      end
+      
+      def print_info(e)
+        e.message.each_line { |line| puts pad(line, INFO_PADDING) }
+        
+        trace = MiniTest.filter_backtrace(e.backtrace)
+        trace.each { |line| puts pad(line, INFO_PADDING) }
+      end
+      
+      def pad(str, size)
+        ' ' * size + str
+      end
+      
+      def pad_mark(str)
+        pad("%#{MARK_SIZE}s" % str, TEST_PADDING)
+      end
+    end
+  end
+end

data/lib/journo/suite_runner.rb

@@ -0,0 +1,110 @@
+module Journo
+  # Runner for MiniTest suites.
+  # 
+  # This is a heavily refactored version of the built-in MiniTest runner. It's
+  # about the same speed, from what I can tell, but is significantly easier to
+  # extend.
+  # 
+  # Based upon Ryan Davis of Seattle.rb's MiniTest (MIT License).
+  # 
+  # @see https://github.com/seattlerb/minitest MiniTest
+  class SuiteRunner < MiniTest::Unit
+    attr_accessor :suite_start_time, :test_start_time, :reporters
+    
+    def initialize
+      self.report = {}
+      self.errors = 0
+      self.failures = 0
+      self.skips = 0
+      self.test_count = 0
+      self.assertion_count = 0
+      self.verbose = false
+      self.reporters = []
+    end
+    
+    def _run_anything(type)
+      self.start_time = Time.now
+      
+      suites = suites_of_type(type)
+      tests = suites.inject({}) do |acc, suite|
+        acc[suite] = filtered_tests(suite, type)
+        acc
+      end
+      
+      self.test_count = tests.inject(0) { |acc, suite| acc + suite[1].length }
+      
+      if test_count > 0
+        trigger(:before_suites, suites, type)
+        
+        fix_sync do
+          suites.each { |suite| _run_suite(suite, tests[suite]) }
+        end
+        
+        trigger(:after_suites, suites, type)
+      end
+    end
+    
+    def _run_suite(suite, tests)
+      unless tests.empty?
+        begin
+          self.suite_start_time = Time.now
+          
+          trigger(:before_suite, suite)
+          suite.startup if suite.respond_to?(:startup)
+          
+          tests.each { |test| _run_test(suite, test) }
+        ensure
+          suite.shutdown if suite.respond_to?(:shutdown)
+          trigger(:after_suite, suite)
+        end
+      end
+    end
+    
+    def _run_test(suite, test)
+      self.test_start_time = Time.now
+      trigger(:before_test, suite, test)
+      
+      test_runner = TestRunner.new(suite, test)
+      test_runner.run
+      add_test_result(suite, test, test_runner)
+      
+      trigger(test_runner.result, suite, test, test_runner)
+    end
+    
+    def trigger(callback, *args)
+      reporters.each { |reporter| reporter.send(callback, *args) }
+    end
+    
+    private
+    
+    def filtered_tests(suite, type)
+      filter = options[:filter] || '/./'
+      filter = Regexp.new($1) if filter =~ /\/(.*)\//
+      suite.send("#{type}_methods").grep(filter)
+    end
+    
+    def suites_of_type(type)
+      TestCase.send("#{type}_suites")
+    end
+    
+    def add_test_result(suite, test, test_runner)
+      self.report[suite] ||= {}
+      self.report[suite][test.to_sym] = test_runner
+      
+      self.assertion_count += test_runner.assertions
+      
+      case test_runner.result
+      when :skip then self.skips += 1
+      when :failure then self.failures += 1
+      when :error then self.errors += 1
+      end
+    end
+    
+    def fix_sync
+      sync = output.respond_to?(:'sync=') # stupid emacs
+      old_sync, output.sync = output.sync, true if sync
+      yield
+      output.sync = old_sync if sync
+    end
+  end
+end

data/lib/journo/test_runner.rb

@@ -0,0 +1,39 @@
+module Journo
+  # Runner for individual MiniTest tests.
+  # 
+  # You *should not* create instances of this class directly. Instances of
+  # {SuiteRunner} will create these and send them to the reporters.
+  # 
+  # Based upon Ryan Davis of Seattle.rb's MiniTest (MIT License).
+  # 
+  # @see https://github.com/seattlerb/minitest MiniTest
+  class TestRunner
+    attr_reader :suite, :test, :assertions, :result, :exception
+    
+    def initialize(suite, test)
+      @suite = suite
+      @test = test
+      @assertions = 0
+    end
+    
+    def run
+      suite_instance = suite.new(test)
+      @result, @exception = fix_result(suite_instance.run(self))
+      @assertions = suite_instance._assertions
+    end
+    
+    def puke(suite, test, exception)
+      case exception
+      when MiniTest::Skip then [:skip, exception]
+      when MiniTest::Assertion then [:failure, exception]
+      else [:error, exception]
+      end
+    end
+    
+    private
+    
+    def fix_result(result)
+      result == '.' ? [:pass, nil] : result
+    end
+  end
+end

data/lib/journo/version.rb

@@ -0,0 +1,3 @@
+module Journo
+  VERSION = '0.2.0'
+end

data/test/journo/reporter_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module JournoTest
+  class ReporterTest < TestCase
+    def setup
+      @reporter = Journo::Reporter.new
+    end
+    
+    test 'callbacks' do
+      [
+        :before_suites, :after_suite, :before_suite, :after_suite, :before_test,
+        :pass, :skip, :failure, :error
+      ].each { |method| assert_respond_to @reporter, method }
+    end
+    
+    test '#runner' do
+      assert_kind_of MiniTest::Unit, @reporter.runner
+    end
+    
+    test '#output' do
+      assert_equal MiniTest::Unit.output, @reporter.output
+    end
+    
+    test '#verbose?' do
+      refute @reporter.verbose?
+      
+      begin
+        @reporter.runner.verbose = true
+        assert @reporter.verbose?
+      ensure
+        @reporter.runner.verbose = false
+      end
+    end
+    
+    test '#print' do
+      @reporter.output.expects(:print).with('foo')
+      @reporter.print('foo')
+    end
+    
+    test '#puts' do
+      @reporter.output.expects(:puts).with('foo')
+      @reporter.puts('foo')
+    end
+  end
+end

data/test/journo/suite_runner_test.rb

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+module JournoTest
+  class SuiteRunnerTest < TestCase
+    def setup
+      @runner = Journo::SuiteRunner.new
+      @reporter = add_reporter
+    end
+    
+    test '#report' do
+      assert_equal({}, @runner.report)
+    end
+    
+    test '#reporters' do
+      assert_equal [@reporter], @runner.reporters
+      
+      reporter2 = add_reporter
+      assert_equal [@reporter, reporter2], @runner.reporters
+    end
+    
+    test '#_run_anything with no suites' do
+      stub_suites([])
+      
+      @reporter.expects(:before_suites).never
+      @reporter.expects(:after_suites).never
+      
+      @runner._run_anything(:test)
+      
+      assert_equal 0, @runner.test_count
+      assert_equal 0, @runner.assertion_count
+      assert_instance_of Time, @runner.start_time
+      assert_equal({}, @runner.report)
+    end
+    
+    test '#_run_anything with suites' do
+      suites = [Fixtures::PassTestFixture, Fixtures::SkipTestFixture]
+      stub_suites(suites)
+      
+      @reporter.expects(:before_suites).with(suites, :test)
+      @reporter.expects(:after_suites).with(suites, :test)
+      
+      @runner._run_anything(:test)
+      
+      assert_equal 3, @runner.test_count
+      assert_equal 3, @runner.assertion_count
+      assert_instance_of Time, @runner.start_time
+      assert_equal :pass, @runner.report[Fixtures::PassTestFixture][:test_pass].result
+      assert_equal :pass, @runner.report[Fixtures::PassTestFixture][:test_foo].result
+      assert_equal :skip, @runner.report[Fixtures::SkipTestFixture][:test_skip].result
+    end
+    
+    test '#_run_anything with a filter' do
+      @runner.options[:filter] = '/foo/'
+      stub_suites([Fixtures::PassTestFixture])
+      
+      @runner._run_anything(:test)
+      assert_equal 2, @runner.assertion_count
+    end
+    
+    test '#_run_suite without tests' do
+      @reporter.expects(:before_suite).never
+      @reporter.expects(:after_suite).never
+      
+      @runner._run_suite(Fixtures::EmptyTestFixture, [])
+    end
+    
+    test '#_run_suite with tests' do
+      @reporter.expects(:before_suite).with(Fixtures::PassTestFixture)
+      @reporter.expects(:after_suite).with(Fixtures::PassTestFixture)
+      
+      @runner._run_suite(Fixtures::PassTestFixture, [:test_pass, :test_foo])
+      
+      assert_equal 3, @runner.assertion_count
+      assert_instance_of Time, @runner.suite_start_time
+    end
+    
+    test '#_run_suite with a suite .startup and .shutdown' do
+      suite = Fixtures::SuiteCallbackTestFixture
+      suite.expects(:startup)
+      suite.expects(:shutdown)
+      @runner._run_suite(suite, [:test_foo])
+    end
+    
+    test '#_run_test with a passing test' do
+      suite = Fixtures::PassTestFixture
+      test = :test_pass
+            
+      @reporter.expects(:before_test).with(suite, test)
+      @reporter.expects(:pass).with(suite, test, instance_of(Journo::TestRunner))
+      
+      @runner._run_test(suite, test)
+      
+      assert_equal 1, @runner.assertion_count
+      assert_instance_of Time, @runner.test_start_time
+      assert_equal :pass, @runner.report[suite][test].result
+    end
+    
+    test '#_run_test with a skipped test' do
+      suite = Fixtures::SkipTestFixture
+      test = :test_skip
+            
+      @reporter.expects(:before_test).with(suite, test)
+      @reporter.expects(:skip).with(suite, test, instance_of(Journo::TestRunner))
+      
+      @runner._run_test(suite, test)
+      
+      assert_equal 0, @runner.assertion_count
+      assert_instance_of Time, @runner.test_start_time
+      assert_equal :skip, @runner.report[suite][test].result
+    end
+    
+    test '#_run_test with a failing test' do
+      suite = Fixtures::FailureTestFixture
+      test = :test_failure
+            
+      @reporter.expects(:before_test).with(suite, test)
+      @reporter.expects(:failure).with(suite, test, instance_of(Journo::TestRunner))
+      
+      @runner._run_test(suite, test)
+      
+      assert_equal 0, @runner.assertion_count
+      assert_instance_of Time, @runner.test_start_time
+      assert_equal :failure, @runner.report[suite][test].result
+    end
+    
+    test '#_run_test with an error test' do
+      suite = Fixtures::ErrorTestFixture
+      test = :test_error
+      
+      @reporter.expects(:before_test).with(suite, test)
+      @reporter.expects(:error).with(suite, test, instance_of(Journo::TestRunner))
+      
+      @runner._run_test(suite, test)
+      
+      assert_equal 0, @runner.assertion_count
+      assert_instance_of Time, @runner.test_start_time
+      assert_equal :error, @runner.report[suite][test].result
+    end
+    
+    test '#trigger' do
+      reporter2 = add_reporter
+      @reporter.expects(:before_suite).with(Fixtures::PassTestFixture)
+      reporter2.expects(:before_suite).with(Fixtures::PassTestFixture)
+      
+      @runner.trigger(:before_suite, Fixtures::PassTestFixture)
+    end
+    
+    private
+    
+    def add_reporter
+      reporter = Journo::Reporter.new
+      @runner.reporters << reporter
+      reporter
+    end
+    
+    def stub_suites(suites)
+      MiniTest::Unit::TestCase.stubs(:test_suites).returns(suites)
+    end
+  end
+end

data/test/journo/test_runner_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+module JournoTest
+  class TestRunnerTest < TestCase
+    def setup
+      @suite = stub
+      @test = :test_foo
+      @runner = Journo::TestRunner.new(@suite, @test)
+    end
+    
+    test '#suite' do
+      assert_equal @suite, @runner.suite
+    end
+    
+    test '#test' do
+      assert_equal @test, @runner.test
+    end
+    
+    test '#run with a passing test' do
+      suite_instance = stub(:_assertions => 3)
+      suite_instance.expects(:run).with(@runner).returns('.')
+      @suite.stubs(:new).with(@test).returns(suite_instance)
+      
+      @runner.run
+      
+      assert_equal :pass, @runner.result
+      assert_nil @runner.exception
+      assert_equal 3, @runner.assertions
+    end
+    
+    test '#run with an skipped test' do
+      error = stub
+      suite_instance = stub(:_assertions => 3)
+      suite_instance.expects(:run).with(@runner).returns([:skip, error])
+      @suite.stubs(:new).with(@test).returns(suite_instance)
+      
+      @runner.run
+      
+      assert_equal :skip, @runner.result
+      assert_equal error, @runner.exception
+      assert_equal 3, @runner.assertions
+    end
+    
+    test '#run with a failing test' do
+      error = stub
+      suite_instance = stub(:_assertions => 3)
+      suite_instance.expects(:run).with(@runner).returns([:failure, error])
+      @suite.stubs(:new).with(@test).returns(suite_instance)
+      
+      @runner.run
+      
+      assert_equal :failure, @runner.result
+      assert_equal error, @runner.exception
+      assert_equal 3, @runner.assertions
+    end
+    
+    test '#run with an errored test' do
+      error = stub
+      suite_instance = stub(:_assertions => 3)
+      suite_instance.expects(:run).with(@runner).returns([:error, error])
+      @suite.stubs(:new).with(@test).returns(suite_instance)
+      
+      @runner.run
+      
+      assert_equal :error, @runner.result
+      assert_equal error, @runner.exception
+      assert_equal 3, @runner.assertions
+    end
+    
+    test '#puke with a skip' do
+      skip = MiniTest::Skip.new
+      result = @runner.puke(@suite, @test, skip)
+      
+      assert_equal [:skip, skip], result
+    end
+    
+    test '#puke with a failure' do
+      failure = MiniTest::Assertion.new
+      result = @runner.puke(@suite, @test, failure)
+      
+      assert_equal [:failure, failure], result
+    end
+    
+    test '#puke with an error' do
+      error = RuntimeError.new
+      result = @runner.puke(@suite, @test, error)
+      
+      assert_equal [:error, error], result
+    end
+  end
+end

data/test/support/fixtures/empty_test_fixture.rb

@@ -0,0 +1,5 @@
+module JournoTest
+  module Fixtures
+    class EmptyTestFixture < TestCaseFixture; end
+  end
+end

data/test/support/fixtures/error_test_fixture.rb

@@ -0,0 +1,9 @@
+module JournoTest
+  module Fixtures
+    class ErrorTestFixture < TestCaseFixture
+      def test_error
+        raise RuntimeError.new
+      end
+    end
+  end
+end

data/test/support/fixtures/failure_test_fixture.rb

@@ -0,0 +1,9 @@
+module JournoTest
+  module Fixtures
+    class FailureTestFixture < TestCaseFixture
+      def test_failure
+        flunk
+      end
+    end
+  end
+end

data/test/support/fixtures/pass_test_fixture.rb

@@ -0,0 +1,14 @@
+module JournoTest
+  module Fixtures
+    class PassTestFixture < TestCaseFixture
+      def test_pass
+        assert true
+      end
+      
+      def test_foo
+        assert true
+        assert true
+      end
+    end
+  end
+end

data/test/support/fixtures/skip_test_fixture.rb

@@ -0,0 +1,9 @@
+module JournoTest
+  module Fixtures
+    class SkipTestFixture < TestCaseFixture
+      def test_skip
+        skip
+      end
+    end
+  end
+end

data/test/support/fixtures/suite_callback_test_fixture.rb

@@ -0,0 +1,9 @@
+module JournoTest
+  module Fixtures
+    class SuiteCallbackTestFixture < TestCaseFixture
+      def self.startup; end
+      def self.shutdown; end
+      def test_foo; end
+    end
+  end
+end

data/test/support/fixtures/test_case_fixture.rb

@@ -0,0 +1,38 @@
+module JournoTest
+  module Fixtures
+    class TestCaseFixture
+      attr_writer :_assertions
+      
+      def self.test_methods
+        public_instance_methods(true).grep(/^test/)
+      end
+      
+      def initialize(test)
+        @test = test
+      end
+      
+      def run(runner)
+        send(@test)
+        '.'
+      rescue MiniTest::Assertion, RuntimeError => e
+        runner.puke(self, @test, e)
+      end
+      
+      def skip
+        raise MiniTest::Skip.new
+      end
+      
+      def flunk
+        raise MiniTest::Assertion.new
+      end
+      
+      def assert(value)
+        self._assertions += 1
+      end
+      
+      def _assertions
+        @_assertions ||= 0
+      end
+    end
+  end
+end

data/test/support/test_case.rb

@@ -0,0 +1,4 @@
+module JournoTest
+  class TestCase < MiniTest::Unit::TestCase
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'mocha'
+require 'test_declarative'
+require 'journo'
+
+module JournoTest
+  require File.expand_path('../support/test_case', __FILE__)
+  
+  module Fixtures
+    require File.expand_path('../support/fixtures/test_case_fixture', __FILE__)
+    require File.expand_path('../support/fixtures/empty_test_fixture', __FILE__)
+    require File.expand_path('../support/fixtures/error_test_fixture', __FILE__)
+    require File.expand_path('../support/fixtures/failure_test_fixture', __FILE__)
+    require File.expand_path('../support/fixtures/pass_test_fixture', __FILE__)
+    require File.expand_path('../support/fixtures/skip_test_fixture', __FILE__)
+    require File.expand_path('../support/fixtures/suite_callback_test_fixture', __FILE__)
+  end
+end
+
+MiniTest::Unit.runner = Journo::SuiteRunner.new
+
+# Testing the built-in reporters using automated unit testing would be extremely
+# brittle. Consequently, there are no unit tests for them. Instead, uncomment
+# the reporter that you'd like to test and run the full test suite. Make sure to
+# try them with skipped, failing, and error tests as well!
+# 
+# Personally, I like the progress reporter. Make sure you don't change that line
+# when you commit.
+# 
+# MiniTest::Unit.runner.reporters << Journo::Reporters::DefaultReporter.new
+# MiniTest::Unit.runner.reporters << Journo::Reporters::SpecReporter.new
+MiniTest::Unit.runner.reporters << Journo::Reporters::ProgressReporter.new

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification 
+name: journo
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Alexander Kern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ansi
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-progressbar
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: maruku
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: test_declarative
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Allows you to extend MiniTest using reporters rather than monkey-patching
+email: 
+- alex@kernul.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- .yardopts
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- journo.gemspec
+- lib/journo.rb
+- lib/journo/reporter.rb
+- lib/journo/reporters/default_reporter.rb
+- lib/journo/reporters/progress_reporter.rb
+- lib/journo/reporters/spec_reporter.rb
+- lib/journo/suite_runner.rb
+- lib/journo/test_runner.rb
+- lib/journo/version.rb
+- test/journo/reporter_test.rb
+- test/journo/suite_runner_test.rb
+- test/journo/test_runner_test.rb
+- test/support/fixtures/empty_test_fixture.rb
+- test/support/fixtures/error_test_fixture.rb
+- test/support/fixtures/failure_test_fixture.rb
+- test/support/fixtures/pass_test_fixture.rb
+- test/support/fixtures/skip_test_fixture.rb
+- test/support/fixtures/suite_callback_test_fixture.rb
+- test/support/fixtures/test_case_fixture.rb
+- test/support/test_case.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/CapnKernul/journo
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: journo
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Reporters for MiniTest
+test_files: 
+- test/journo/reporter_test.rb
+- test/journo/suite_runner_test.rb
+- test/journo/test_runner_test.rb
+- test/support/fixtures/empty_test_fixture.rb
+- test/support/fixtures/error_test_fixture.rb
+- test/support/fixtures/failure_test_fixture.rb
+- test/support/fixtures/pass_test_fixture.rb
+- test/support/fixtures/skip_test_fixture.rb
+- test/support/fixtures/suite_callback_test_fixture.rb
+- test/support/fixtures/test_case_fixture.rb
+- test/support/test_case.rb
+- test/test_helper.rb