test-unit-runner-tap 1.0.0 → 1.1.1

data/lib/test/unit/ui/tap/json_testrunner.rb

@@ -0,0 +1,55 @@
+require 'test/unit/ui/tap/base_testrunner'
+
+module Test
+  module Unit
+    module UI
+      module Tap
+
+        # TAP-J report format.
+        #
+        class JSONTestRunner < Tap::BaseTestRunner
+          def initialize(suite, options={})
+            require 'json' unless respond_to?(:to_json)
+            super(suite, options)
+          end
+          def tapout_before_suite(suite)
+            puts super(suite).to_json
+          end
+          def tapout_before_case(testcase)
+            doc = super(testcase)
+            puts doc.to_json if doc
+          end
+          def tapout_note(note)
+            doc = super(note)
+            puts doc.to_json if doc
+          end
+          def tapout_pass(test)
+            doc = super(test)
+            puts doc.to_json if doc
+          end
+          def tapout_fail(test)
+            doc = super(test)
+            puts doc.to_json if doc
+          end
+          def tapout_omit(test)
+            doc = super(test)
+            puts doc.to_json if doc
+          end
+          def tapout_todo(test)
+            doc = super(test)
+            puts doc.to_json if doc
+          end
+          def tapout_error(test)
+            doc = super(test)
+            puts doc.to_json if doc
+          end
+          def tapout_after_suite(time)
+            doc = super(time)
+            puts doc.to_json if doc
+          end
+        end
+
+      end #module Tap
+    end #module UI
+  end #module Unit
+end #module Test

data/lib/test/unit/ui/tap/perl_testrunner.rb

@@ -0,0 +1,181 @@
+require 'test/unit/ui/testrunner'
+require 'test/unit/ui/testrunnermediator'
+require 'test/unit/ui/tap/base_testrunner'
+
+module Test
+  module Unit
+    module UI
+      module Tap
+
+        # Outputs test results in traditional TAP format, version 12.
+        #
+        class PerlTestRunner < BaseTestRunner
+          #
+          def tapout_before_suite(suite)
+            doc = super(suite)
+            @i = 0
+            puts "1..#{doc['count']}"
+          end
+
+          #
+          def tapout_pass(test)
+            doc = super(test)
+            if doc
+              @i += 1
+              puts "ok #{@i} - #{doc['label']}(#{@test_case.name})"
+            end
+          end
+
+          #
+          def tapout_fail(fault)
+            doc = super(fault)
+            if doc
+              @i += 1
+              puts "not ok #{@i} - #{doc['label']}(#{@test_case.name})"
+              puts subdata(doc, 'FAIL')
+            end
+          end
+
+          #
+          def tapout_error(fault)
+            doc = super(fault)
+            if doc
+              @i += 1
+              puts "not ok #{@i} - #{doc['label']}(#{@test_case.name})"
+              puts subdata(doc, 'ERROR')
+            end
+          end
+
+          #
+          def tapout_omit(test)
+            doc = super(fault)
+            if doc
+              @i += 1
+              puts "not ok #{@i} - #{doc['label']}(#{@test_case.name})  # SKIP"
+              puts subdata(doc, 'SKIP')
+            end
+          end
+
+          #
+          def tapout_todo(test)
+            doc = super(fault)
+            if doc
+              @i += 1
+              puts "not ok #{@i} - #{doc['label']}(#{@test_case.name})  # TODO"
+              puts subdata(doc, 'TODO')
+            end
+          end
+
+          #
+          def tapout_note(note)
+            doc = super(note)
+            puts '# ' + doc['text'].gsub("\n", "\n# ")
+          end
+
+          #
+          def tapout_after_suite(time)
+            puts("# Finished in #{time} seconds.")
+            @result.to_s.each_line do |line|
+              puts("# #{line}")
+            end
+          end
+
+        private
+
+          # TODO: Should this use test-unit's `fault.long_display`?
+
+          #
+          def subdata(doc, type)
+            exp       = doc['exception']
+            exp_class = exp['class']
+            message   = exp['message']
+            backtrace = exp['backtrace']
+            file      = exp['file']
+            line      = exp['line']
+
+            body = []
+            body << "%s (%s)" % [type, exp_class]
+            body << message.to_s
+
+            backtrace[0..0].each do |bt|
+              body << bt.to_s
+            end
+
+            code_snippet_string(file, line).each_line do |s|
+              body << s.chomp
+            end
+
+            backtrace[1..-1].each do |bt|
+              body << bt.to_s
+            end
+
+            body = body.join("\n").gsub(/^/, '# ')
+          end
+
+        end
+
+        # TestUnit's original TAP testrunner.
+        #
+        # We keep this runner for the time being as a fallback as the new
+        # code matures.
+        #
+        class OldTestRunner < UI::TestRunner
+          def initialize(suite, options={})
+            super
+            @output = @options[:output] || STDOUT
+            @n_tests = 0
+            @already_outputted = false
+          end
+
+          private
+          def attach_to_mediator
+            @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
+            @mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
+            @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
+            @mediator.add_listener(TestCase::STARTED, &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
+          end
+
+          def add_fault(fault)
+            puts("not ok #{@n_tests} - #{fault.short_display}")
+            fault.long_display.each_line do |line|
+              puts("# #{line}")
+            end
+            @already_outputted = true
+          end
+
+          def started(result)
+            @result = result
+            puts("1..#{@suite.size}")
+          end
+
+          def finished(elapsed_time)
+            puts("# Finished in #{elapsed_time} seconds.")
+            @result.to_s.each_line do |line|
+              puts("# #{line}")
+            end
+          end
+
+          def test_started(name)
+            @n_tests += 1
+          end
+
+          def test_finished(name)
+            unless @already_outputted
+              puts("ok #{@n_tests} - #{name}")
+            end
+            @already_outputted = false
+          end
+
+          def puts(*args)
+            @output.puts(*args)
+            @output.flush
+          end
+        end
+
+      end
+    end
+  end
+end
+
+# Copyright (c) 2012 Trans & Kouhei Sutou (LGPL v3.0)

data/lib/test/unit/ui/tap/yaml_testrunner.rb

@@ -0,0 +1,56 @@
+require 'test/unit/ui/tap/base_testrunner'
+
+module Test
+  module Unit
+    module UI
+      module Tap
+
+        # TAP-Y report format.
+        #
+        class YAMLTestRunner < Tap::BaseTestRunner
+          def initialize(suite, options={})
+            require 'yaml' unless respond_to?(:to_yaml)
+            super(suite, options)
+          end
+          def tapout_before_suite(suite)
+            puts super(suite).to_yaml
+          end
+          def tapout_before_case(testcase)
+            doc = super(testcase)
+            puts doc.to_yaml if doc
+          end
+          def tapout_note(note)
+            doc = super(note)
+            puts doc.to_yaml if doc
+          end
+          def tapout_pass(test)
+            doc = super(test)
+            puts doc.to_yaml if doc
+          end
+          def tapout_fail(test)
+            doc = super(test)
+            puts doc.to_yaml if doc
+          end
+          def tapout_omit(test)
+            doc = super(test)
+            puts doc.to_yaml if doc
+          end
+          def tapout_todo(test)
+            doc = super(test)
+            puts doc.to_yaml if doc
+          end
+          def tapout_error(test)
+            doc = super(test)
+            puts doc.to_yaml if doc
+          end
+          def tapout_after_suite(time)
+            doc = super(time)
+            puts doc.to_yaml if doc
+            puts "..."
+          end
+        end
+
+      end #module Tap
+    end #module UI
+  end #module Unit
+end #module Test

data/test/fixtures/test_example.rb

@@ -0,0 +1,21 @@
+gem 'test-unit'
+require 'test/unit'
+#require 'test/unit/runner/tap'
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/test/unit/runner/tap')
+
+class ExampleTestCase < Test::Unit::TestCase
+  def test_error
+    raise
+  end
+
+  def test_failing
+    assert_equal('1', '2')
+  end
+
+  def test_passing
+    sleep 1
+    assert_equal('1', '1')
+  end
+end
+
+

data/test/run-test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+$KCODE = "utf8" unless "".respond_to?(:encoding)
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+$LOAD_PATH.unshift(lib_dir)
+
+gem 'test-unit'  # until require 'test-unit'
+
+require 'test/unit'
+
+#test_unit_notify_base_dir = File.join(base_dir, "..", "test-unit-notify")
+#test_unit_notify_base_dir = File.expand_path(test_unit_notify_base_dir)
+#if File.exist?(test_unit_notify_base_dir)
+#  $LOAD_PATH.unshift(File.join(test_unit_notify_base_dir, "lib"))
+#  require 'test/unit/notify'
+#end
+
+files = Dir[File.join(test_dir, 'test_*.rb')]
+
+exit Test::Unit::AutoRunner.run(true, test_dir, files)
+

data/test/test_tap.rb

@@ -1,7 +1,10 @@
 # encoding: UTF-8
 
+# TODO: I don't think that `test-unit-runner-tap` should be showing up
+# in backtraces, it should be filtered out.
+
 require 'stringio'
-require 'test/unit/ui/tap/testrunner'
+require 'test/unit/ui/tap/perl_testrunner'
 
 class TestTap < Test::Unit::TestCase
   def test_run
@@ -14,24 +17,26 @@ class TestTap < Test::Unit::TestCase
       def test_fail; assert_equal(3, 1 - 2); end; fail_line = __LINE__
     end
     output = StringIO.new
-    runner = Test::Unit::UI::Tap::TestRunner.new(test_case.suite,
-                                                 :output => output)
+    runner = Test::Unit::UI::Tap::PerlTestRunner.new(test_case.suite, :output => output)
     result = runner.start; start_line = __LINE__
     assert_equal(<<-EOR, output.string.gsub(/[\d\.]+ seconds/, "0.001 seconds"))
 1..2
-not ok 1 - test_fail(): <3> expected but was
-# Failure:
-# test_fail()
-#     [#{__FILE__}:#{fail_line}:in `test_fail'
-#      #{File.expand_path(__FILE__+'/../..')}/lib/test/unit/ui/tap/testrunner.rb:27:in `start'
-#      #{__FILE__}:#{start_line}:in `test_run']:
+not ok 1 - test_fail()
+# FAIL (Test::Unit::Failure)
 # <3> expected but was
 # <-1>.
+# test/test_tap.rb:17
+#    15       end
+#    16 
+# => 17       def test_fail; assert_equal(3, 1 - 2); end; fail_line = __LINE__
+#    18     end
+#    19     output = StringIO.new
+# test/test_tap.rb:21
 ok 2 - test_success()
 # Finished in 0.001 seconds.
 # 2 tests, 2 assertions, 1 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
 EOR
-    assert_true(result.passed?)
+    assert_false(result.passed?)    # think this is correct, where as original runner had it wrong
   end
 end
 

data/test/test_tap0.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+# TODO: I don't think that `test-unit-runner-tap` should be showing up
+# in backtraces, it should be filtered out.
+
+require 'stringio'
+require 'test/unit/ui/tap/perl_testrunner'
+
+class TestTap0 < Test::Unit::TestCase
+  def test_run
+    fail_line = nil
+    test_case = Class.new(Test::Unit::TestCase) do
+      def test_success
+        assert_equal(3, 1 + 2)
+      end
+
+      def test_fail; assert_equal(3, 1 - 2); end; fail_line = __LINE__
+    end
+    output = StringIO.new
+    runner = Test::Unit::UI::Tap::OldTestRunner.new(test_case.suite, :output => output)
+    result = runner.start; start_line = __LINE__
+    assert_equal(<<-EOR, output.string.gsub(/[\d\.]+ seconds/, "0.001 seconds"))
+1..2
+not ok 1 - test_fail(): <3> expected but was
+# Failure:
+# test_fail()
+#     [#{__FILE__}:#{fail_line}:in `test_fail'
+#      #{__FILE__}:#{start_line}:in `test_run']:
+# <3> expected but was
+# <-1>.
+ok 2 - test_success()
+# Finished in 0.001 seconds.
+# 2 tests, 2 assertions, 1 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
+EOR
+    assert_false(result.passed?)
+  end
+end
+

data/test/test_tapy.rb

@@ -0,0 +1,116 @@
+require 'test/unit'
+require 'yaml'
+
+class TapYTest < Test::Unit::TestCase
+
+  def initialize(*args)
+    super(*args)
+
+    @stream = tap_stream_using_format('tapy')
+
+    # These three documents are the unit tests, which can occur in any order.
+    # There is one that shoud have a status of `pass`, another of `fail` and the
+    # third of `error`.
+    @passing_test = @stream.find{ |d| d['type'] == 'test' && d['status'] == 'pass' }
+    @failing_test = @stream.find{ |d| d['type'] == 'test' && d['status'] == 'fail' }
+    @erring_test  = @stream.find{ |d| d['type'] == 'test' && d['status'] == 'error' }
+  end
+
+  def test_there_should_be_six_sections
+    assert_equal 6, @stream.size
+  end
+
+  def test_first_document_should_be_suite
+    assert_equal 'suite', @stream.first['type']
+    assert_equal 3,       @stream.first['count']
+  end
+
+  def test_second_document_should_be_case
+    assert_equal 'case',            @stream[1]['type']
+    assert_equal 'ExampleTestCase', @stream[1]['label']
+    assert_equal 0,                 @stream[1]['level']
+  end
+
+  def test_passing_should_have_correct_label
+    assert_equal 'test_passing', @passing_test['label']
+  end
+
+  def test_failing_should_have_correct_label
+    assert_equal "test_failing", @failing_test['label']
+  end
+
+  def test_failing_should_hash_correct_exception
+    file = "test/fixtures/test_example.rb"
+    assert_equal "Test::Unit::Failure",    @failing_test['exception']['class']
+    assert_equal file,                     @failing_test['exception']['file']
+    assert_equal 12,                       @failing_test['exception']['line']
+    assert_equal "assert_equal('1', '2')", @failing_test['exception']['source']
+  end
+
+  def test_failing_should_have_test_unit_in_backtrace
+    @failing_test['exception']['backtrace'].each do |e|
+      assert_not_match(/test\/unit/, e)
+    end
+  end
+
+  def test_erring_should_have_correct_label
+    assert_equal 'test_error', @erring_test['label']
+  end
+
+  def test_erring_should_have_correct_exception
+    file = "test/fixtures/test_example.rb"
+    assert_equal 'Test::Unit::Error', @erring_test['exception']['class']
+    assert_equal file,                @erring_test['exception']['file']
+    assert_equal 8,                   @erring_test['exception']['line']
+    assert_equal 'raise',             @erring_test['exception']['source']
+  end
+
+  def test_erring_should_not_mention_testunit_in_backtrace
+    @erring_test['exception']['backtrace'].each do |e|
+      assert_not_match(/test\/unit/, e)
+    end
+  end
+
+  def test_last_should_be_a_final_document
+    assert_equal 'final', @stream.last['type']
+  end
+
+  def test_last_should_have_prpoer_counts
+    assert_equal 3, @stream.last['counts']['total']
+    assert_equal 1, @stream.last['counts']['error']
+    assert_equal 1, @stream.last['counts']['fail']
+    assert_equal 1, @stream.last['counts']['pass']
+    assert_equal 0, @stream.last['counts']['omit']
+    assert_equal 0, @stream.last['counts']['todo']
+  end
+
+private
+
+  FIXTURE = File.dirname(__FILE__) + '/fixtures'
+
+  def tap_stream_using_format(type)
+    command = "ruby -Ilib #{FIXTURE}/test_example.rb --runner #{type}"
+    output  = `#{command}`
+
+    begin
+      #@stream = YAML.load_documents(@out)  # b/c of bug in Ruby 1.8
+      @stream = (
+        s = []
+        load_stream(output){ |d| s << d }
+        s
+      )
+    rescue Exception
+      puts output
+      raise
+    end
+  end
+
+  def load_stream(output, &block)
+    if RUBY_VERSION < '1.9'
+      YAML.load_documents(output, &block)
+    else
+      YAML.load_stream(output).each(&block)
+    end
+  end
+
+end