tunit 0.0.1

data/lib/tunit/compound_reporter.rb

@@ -0,0 +1,33 @@
+require 'tunit/reporter'
+
+module Tunit
+  class CompoundReporter < Reporter
+    def initialize *reporters
+      super()
+      self.reporters = reporters
+    end
+    attr_accessor :reporters
+
+    def << reporter
+      self.reporters << reporter
+    end
+
+    def passed?
+      self.reporters.all?(&:passed?)
+    end
+
+    def start
+      self.reporters.each(&:start)
+    end
+
+    def record result
+      self.reporters.each do |reporter|
+        reporter.record result
+      end
+    end
+
+    def report
+      self.reporters.each(&:report)
+    end
+  end
+end

data/lib/tunit/hooks.rb

@@ -0,0 +1,11 @@
+module Tunit
+  module Hooks
+    # Runs before each test
+    def setup
+    end
+
+    # Runs after each test
+    def teardown
+    end
+  end
+end

data/lib/tunit/progress_reporter.rb

@@ -0,0 +1,11 @@
+require 'tunit/reporter'
+
+module Tunit
+  class ProgressReporter < Reporter
+    def record result
+      io.print result.code
+      io.print " = %s#%s (%.2f s)" % [result.class, result.name, result.time] if options[:verbose]
+      io.puts if options[:verbose]
+    end
+  end
+end

data/lib/tunit/reporter.rb

@@ -0,0 +1,39 @@
+module Tunit
+  class Reporter
+    def initialize io = $stdout, options = {}
+      self.io         = io
+      self.options    = options
+      self.assertions = 0
+      self.count      = 0
+      self.results    = []
+    end
+    attr_accessor :io, :options, :assertions, :count, :results
+    attr_accessor :start_time, :total_time
+    attr_accessor :failures, :skips, :errors
+
+    def start
+      self.start_time = Time.now
+    end
+
+    def record result
+      self.count += 1
+      self.assertions += result.assertions
+
+      self.results << result if !result.passed? || result.skipped?
+    end
+
+    def passed?
+      results.all?(&:skipped?)
+    end
+
+    def report
+      total           = results.group_by {|r| r.failure.class }
+      total.default   = []
+
+      self.total_time   = Time.now - start_time
+      self.failures     = total[Assertion].size
+      self.failures    += total[Empty].size
+      self.skips        = total[Skip].size
+    end
+  end
+end

data/lib/tunit/runnable.rb

@@ -0,0 +1,51 @@
+module Tunit
+  class Runnable
+    def self.runnable_methods
+      raise NotImplementedError, "subclass responsibility"
+    end
+
+    def self.runnables
+      @@runnables ||= []
+    end
+
+    def self.runnables= runnable
+      @@runnables = [runnable].flatten
+    end
+
+    def self.inherited klass
+      self.runnables << klass
+      super
+    end
+
+    def self.run reporter, options = {}
+      filter = options.fetch(:filter) { '/./' }
+      filter = Regexp.new $1 if filter =~ /\/(.*)\//
+
+      filtered_methods = self.runnable_methods.select { |m|
+        filter === m || filter === "#{self}##{m}"
+      }
+
+      filtered_methods.each { |test|
+        reporter.record self.new(test).run
+      }
+    end
+
+    def initialize name
+      self.name       = name
+      self.assertions = 0
+      self.failures   = []
+    end
+    attr_accessor :name, :assertions, :failures, :time
+
+
+    def run
+      fail NotImplementedError, "subclass responsibility"
+    end
+
+    private
+
+    def self.methods_matching re
+      public_instance_methods(true).grep(re).map(&:to_s)
+    end
+  end
+end

data/lib/tunit/spec.rb

@@ -0,0 +1,77 @@
+require 'tunit/test'
+
+module Kernel
+  # Override describe to avoid warnings and collisions with minitest/spec
+  alias_method :_old_describe, :describe if defined? Minitest
+  def describe desc, &blk
+    _old_describe desc, &blk if defined? Minitest
+
+    super_klass = if Class === self && is_a?(Tunit::Spec::DSL)
+                    self
+                  else
+                    Tunit::Spec
+                  end
+
+    klass = super_klass.create desc
+    klass.class_eval(&blk)
+    klass
+  end
+end
+
+module Tunit
+  class Spec < Test
+    module DSL
+      attr_reader :name
+
+      def before &block
+        define_method :setup do
+          self.instance_eval(&block)
+        end
+      end
+
+      def after &block
+        define_method :teardown do
+          self.instance_eval(&block)
+        end
+      end
+
+      def it desc, &block
+        block ||= -> { skip "(no tests defined)" }
+
+        @specs ||= 0
+        @specs += 1
+
+        test_name = desc.gsub " ", "_"
+        name      = "test_%04d_%s" % [ @specs, test_name ]
+
+        define_method name, &block
+
+        name
+      end
+
+      def children
+        @children ||= []
+      end
+
+      def create name
+        klass = Class.new(self) {
+          @name = name
+
+          remove_test_methods!
+        }
+
+        children << klass
+
+        klass
+      end
+
+      def remove_test_methods!
+        self.runnable_methods.map { |test|
+          self.send :undef_method, test
+        }
+      end
+    end
+
+    extend DSL
+  end
+end

data/lib/tunit/summary_reporter.rb

@@ -0,0 +1,50 @@
+require 'tunit/reporter'
+
+module Tunit
+  class SummaryReporter < Reporter
+    SKIP_MSG = "\n\nYou have skipped tests. Run with --verbose for details."
+
+    def start
+      super
+
+      io.puts "Run options: #{options.inspect}"
+      io.puts
+      io.puts "# Running:"
+      io.puts
+    end
+
+    def report
+      super
+
+      io.puts unless options[:verbose]
+      io.puts
+      io.puts statistics
+      io.puts aggregated_results
+      io.puts summary
+    end
+
+    private
+
+    def statistics
+      "Finished in %.6fs, %.4f runs/s, %.4f assertions/s." %
+        [total_time, count / total_time, assertions / total_time]
+    end
+
+    def aggregated_results
+      filtered_results = results.dup
+      filtered_results.reject!(&:skipped?) unless options[:verbose]
+
+      filtered_results.each_with_index.map do |result, index|
+        "\n%3d) %s" % [index + 1, result]
+      end.join + "\n"
+    end
+
+    def summary
+      extra = ""
+      extra << SKIP_MSG if results.any?(&:skipped?) && !options[:verbose]
+
+      "%d runs, %d assertions, %d failures, %d skips%s" %
+        [count, assertions, failures, skips, extra]
+    end
+  end
+end

data/lib/tunit/test.rb

@@ -0,0 +1,104 @@
+require 'tunit/runnable'
+require 'tunit/assertions'
+require 'tunit/hooks'
+
+module Tunit
+  class Test < Runnable
+    include Assertions
+    include Hooks
+    PREFIX = /^test_/
+
+    def self.runnable_methods
+      methods = methods_matching PREFIX
+      case self.test_order
+      when :random
+        max = methods.size
+        methods.sort.sort_by { rand max }
+      when :alpha
+        methods.sort
+      else
+        raise "Unknown test_order: #{self.test_order.inspect}"
+      end
+    end
+
+    # Randomize tests by default
+    def self.test_order
+      :random
+    end
+
+    def self.order!
+      class << self
+        undef_method :test_order if method_defined?(:test_order)
+        define_method(:test_order) { :alpha }
+      end
+    end
+
+    def run
+      capture_exceptions do
+        time_it do
+          setup
+          send name
+        end
+
+        if self.assertions.zero?
+          begin
+            fail ::Tunit::Empty, "Empty test, '#{self.to_s}'"
+          rescue ::Tunit::Empty => e
+            method_obj = self.method(name)
+            e.location = method_obj.source_location.join(":")
+            raise e
+          end
+        end
+      end
+
+      capture_exceptions do
+        teardown
+      end
+      self
+    end
+
+    def passed?
+      !failure
+    end
+
+    def skipped?
+      failure && Skip === failure
+    end
+
+    def failure
+      self.failures.first
+    end
+
+    def code
+      failure && failure.result_code || "."
+    end
+
+    def location
+      loc = " [#{self.failure.location}]" unless passed?
+      "#{self.class}##{self.name}#{loc}"
+    end
+
+    def to_s
+      return location if passed? && !skipped?
+
+      failures.map { |failure|
+        "#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
+      }.join "\n"
+    end
+
+    private
+
+    def time_it
+      t0 = Time.now
+      yield
+    ensure
+      self.time = Time.now - t0
+    end
+
+    def capture_exceptions
+      yield
+    rescue Assertion => e
+      self.failures << e
+    end
+  end
+end

data/lib/tunit/version.rb

@@ -0,0 +1,3 @@
+module Tunit
+  VERSION = "0.0.1"
+end

data/test/rtest_test.rb

@@ -0,0 +1,19 @@
+require_relative 'tunit/test_case'
+require 'tunit'
+
+class TunitTest < Tunit::TestCase
+  def setup
+    Tunit.io = io
+    Tunit::Runnable.runnables = [PassingTest]
+  end
+
+  def test_run_gathers_reporters_under_compound_reporter
+    Tunit.run
+    assert_instance_of Tunit::CompoundReporter, Tunit.reporter
+  end
+
+  def test_run_dispatches_the_reporters_to_run
+    Tunit.run
+    assert Tunit.reporter.passed?
+  end
+end

data/test/tunit/assertion_errors_test.rb

@@ -0,0 +1,95 @@
+require_relative 'test_case'
+require 'tunit/assertion_errors'
+require 'tunit/test'
+
+module Tunit
+  class AssertionErrotunit < TestCase
+    def setup
+      self.assertion = Assertion.new
+    end
+    attr_accessor :assertion
+
+    def test_error
+      assert_instance_of Assertion, assertion.error
+    end
+
+    def test_location
+      result       = FailingTest.new.run
+      assertion    = result.failure
+      exp_location = %r(.*/tunit/test/tunit/test_case.rb:\d{1,})
+
+      assert_match exp_location, assertion.location
+    end
+
+    def test_result_code
+      assert_equal "F", assertion.result_code
+    end
+
+    def test_result_label
+      assert_equal "Failure", assertion.result_label
+    end
+  end
+
+  class EmptyTest < TestCase
+    def setup
+      self.assertion = Empty.new
+    end
+    attr_accessor :assertion
+
+    def test_error
+      assert_instance_of Empty, assertion.error
+    end
+
+    def test_location
+      result       = FailingTest.new(:test_empty).run
+      assertion    = result.failure
+      exp_location = %r(.*/tunit/test/tunit/test_case.rb:\d{1,})
+
+      assert_match exp_location, assertion.location
+    end
+
+    def test_location_handles_unnamed_classes
+      result = Class.new(Test) {
+        def test_empty
+        end
+      }.new(:test_empty).run
+
+      refute_equal :not_set, result.failure.location
+    end
+
+    def test_result_code
+      assert_equal "_", assertion.result_code
+    end
+
+    def test_result_label
+      assert_equal "Empty", assertion.result_label
+    end
+  end
+
+  class SkipTest < TestCase
+    def setup
+      self.assertion = Skip.new
+    end
+    attr_accessor :assertion
+
+    def test_error
+      assert_instance_of Skip, assertion.error
+    end
+
+    def test_location
+      result       = SkippedTest.new.run
+      assertion    = result.failure
+      exp_location = %r(.*/tunit/test/tunit/test_case.rb:\d{1,})
+
+      assert_match exp_location, assertion.location
+    end
+
+    def test_result_code
+      assert_equal "S", assertion.result_code
+    end
+
+    def test_result_label
+      assert_equal "Skipped", assertion.result_label
+    end
+  end
+end