tunit 0.0.1

data/test/tunit/assertions_test.rb

@@ -0,0 +1,68 @@
+require_relative 'test_case'
+require 'tunit/assertions'
+require 'tunit/test'
+
+module Tunit
+  class AssertionsTest < TestCase
+    def setup
+      self.tc = Class.new(Test).new "name"
+      self.assertion_count = 0
+    end
+    attr_accessor :tc, :assertion_count
+
+    def teardown
+      assert_equal assertion_count, tc.assertions,
+        "Expected #{assertion_count} assertions to have been made to #{tc.inspect}, but was #{tc.assertions}"
+    end
+
+    def test_assert
+      self.assertion_count = 1
+      tc.assert "truthy"
+    end
+
+    def test_refute
+      self.assertion_count = 1
+      tc.refute false
+    end
+
+    def test_assert_equal
+      self.assertion_count = 1
+      tc.assert_equal 1, 1
+    end
+
+    def test_refute_equal
+      self.assertion_count = 1
+      tc.refute_equal 1, 2
+    end
+
+    def test_assert_includes
+      self.assertion_count = 2
+      tc.assert_includes [2], 2
+    end
+
+    def test_refute_includes
+      self.assertion_count = 2
+      tc.refute_includes [1], 2
+    end
+
+    def test_assert_respond_to
+      self.assertion_count = 1
+      tc.assert_respond_to tc, :assert
+    end
+
+    def test_refute_respond_to
+      self.assertion_count = 1
+      tc.refute_respond_to tc, :omg
+    end
+
+    def test_assert_instance_of
+      self.assertion_count = 1
+      tc.assert_instance_of String, "omg"
+    end
+
+    def test_refute_instance_of
+      self.assertion_count = 1
+      tc.refute_instance_of String, 1
+    end
+  end
+end

data/test/tunit/progress_reporter_test.rb

@@ -0,0 +1,45 @@
+require_relative 'test_case'
+require 'tunit/progress_reporter'
+
+module Tunit
+  class ProgressReporterTest < TestCase
+    def setup
+      self.reporter = ProgressReporter.new io
+    end
+    attr_accessor :reporter
+
+    def test_record_passing_tests
+      reporter.record PassingTest.new.run
+
+      assert_equal ".", io.string
+    end
+
+    def test_record_skipped_tests
+      reporter.record SkippedTest.new.run
+
+      assert_equal "S", io.string
+    end
+
+    def test_record_failing_tests
+      reporter.record FailingTest.new.run
+
+      assert_equal "F", io.string
+    end
+
+    def test_record_empty_tests
+      reporter.record FailingTest.new(:test_empty).run
+
+      assert_equal "_", io.string
+    end
+
+    def test_record_is_very_verbose
+      reporter = ProgressReporter.new io, verbose: true
+      reporter.record PassingTest.new(:test_pass).run
+      exp_verbosity = <<-EOS
+. = Tunit::TestCase::PassingTest#test_pass (0.00 s)
+      EOS
+
+      assert_equal exp_verbosity, io.string
+    end
+  end
+end

data/test/tunit/reporter_test.rb

@@ -0,0 +1,66 @@
+require_relative './test_case'
+require 'tunit/reporter'
+
+module Tunit
+  class ReporterTest < TestCase
+    def setup
+      self.reporter = Reporter.new
+    end
+    attr_accessor :reporter
+
+    def test_start_time
+      reporter.start
+
+      assert_instance_of Time, reporter.start_time
+    end
+
+    def test_record_passing_test
+      reporter.record PassingTest.new.run
+
+      assert_equal 1, reporter.count
+      assert_equal 1, reporter.assertions
+    end
+
+    def test_record_failing_test
+      reporter.record FailingTest.new.run
+
+      assert_equal 1, reporter.results.size
+    end
+
+    def test_passed_eh
+      reporter.record PassingTest.new.run
+
+      assert reporter.passed?
+    end
+
+    def test_passed_eh_is_only_for_passing_tests
+      reporter.record FailingTest.new.run
+
+      refute reporter.passed?
+    end
+
+    def test_report_collects_total_time
+      reporter.start
+      reporter.record PassingTest.new.run
+      reporter.report
+
+      assert_instance_of Float, reporter.total_time
+    end
+
+    def test_report_collects_failures
+      reporter.start
+      reporter.record FailingTest.new.run
+      reporter.report
+
+      assert_equal 1, reporter.failures
+    end
+
+    def test_report_collects_skips
+      reporter.start
+      reporter.record SkippedTest.new.run
+      reporter.report
+
+      assert_equal 1, reporter.skips
+    end
+  end
+end

data/test/tunit/runnable_test.rb

@@ -0,0 +1,69 @@
+require_relative 'test_case'
+require 'tunit/runnable'
+
+module Tunit
+  class RunnableTest < TestCase
+    def test_runnable_methods_is_a_subclass_responsibility
+      e = assert_raises NotImplementedError do
+        Runnable.runnable_methods
+      end
+
+      exp = "subclass responsibility"
+      assert_equal exp, e.message
+    end
+
+    def test_runnables_list_all_runnables_that_inherit_from_runnable
+      assert_includes Runnable.runnables, PassingTest
+    end
+
+    def test_runnables_custom
+      prev_runnables = Runnable.runnables
+
+      Runnable.runnables = "omg"
+      assert_includes Runnable.runnables, "omg"
+
+      # reset Runnable.runnables to avoid mishaps, teardown didn't pull through
+    ensure
+      Runnable.runnables = prev_runnables
+    end
+
+    def test_run_runs_all_tests_with_a_given_reporter
+      PassingTest.run dummy_reporter, io: io
+
+      assert_equal dummy_reporter.report, PassingTest.runnable_methods.size
+    end
+
+    def test_run_runs_all_tests_with_matching_pattern
+      filter          = "test_pass_one_more"
+      matched_methods = PassingTest.runnable_methods.grep(/#{filter}/).size
+
+      PassingTest.run dummy_reporter, io: io, filter: filter
+
+      assert_equal dummy_reporter.report, matched_methods
+    end
+
+    def test_runnable_methods_can_be_customized_to_find_your_tests
+      super_klass = Class.new(Runnable) {
+        def self.runnable_methods
+          methods_matching(/^spec_/)
+        end
+      }
+
+      klass = Class.new(super_klass) {
+        def spec_foo; end
+        def foo_test; end
+      }
+
+      assert_includes klass.runnable_methods, "spec_foo"
+    end
+
+    def test_run_is_a_subclass_responsibility
+      e = assert_raises NotImplementedError do
+        Runnable.new("name").run
+      end
+
+      exp = "subclass responsibility"
+      assert_equal exp, e.message
+    end
+  end
+end

data/test/tunit/spec_test.rb

@@ -0,0 +1,57 @@
+require_relative 'test_case'
+require 'tunit/spec'
+
+MyThing       = Class.new
+MySecondThing = Class.new
+
+module Tunit
+  class SpecTest < TestCase
+    def test_it_blocks_are_converted_to_test_methods
+      klass = Class.new(::Tunit::Spec) {
+        it "does the thing" do end
+      }
+
+      klass.new "blah"
+
+      assert_includes klass.runnable_methods, "test_0001_does_the_thing"
+    end
+
+    def test_before_is_converted_to_setup
+      klass = Class.new(::Tunit::Spec)
+      klass.before { "here!" }
+
+      assert_respond_to klass.new(:test), :setup
+      assert_equal "here!", klass.new(:test).setup
+    end
+
+    def test_after_is_converted_to_teardown
+      klass = Class.new(::Tunit::Spec)
+      klass.after { "there!" }
+
+      assert_respond_to klass.new(:test), :teardown
+      assert_equal "there!", klass.new(:test).teardown
+    end
+
+    def test_describe_is_converted_to_a_test_klass_with_test_methods
+      my_thing = describe MyThing do
+        it 'dances all night long' do end
+      end
+
+      assert_includes my_thing.ancestors, ::Tunit::Test
+      assert_includes my_thing.runnable_methods, "test_0001_dances_all_night_long"
+    end
+
+    def test_describe_can_be_nested
+      my_second_thing = describe MySecondThing do
+        describe '#dance!' do
+          it 'busts the moves' do end
+        end
+      end
+
+      child = my_second_thing.children.pop
+
+      assert_equal "#dance!", child.name
+      assert_includes child.runnable_methods, "test_0001_busts_the_moves"
+    end
+  end
+end

data/test/tunit/summary_reporter_test.rb

@@ -0,0 +1,116 @@
+require_relative 'test_case'
+require 'tunit/summary_reporter'
+
+module Tunit
+  class SummaryReporterTest < TestCase
+    def setup
+      self.reporter = SummaryReporter.new io
+    end
+    attr_accessor :reporter
+
+    def test_start_returns_run_msg
+      reporter.start
+      exp_msg = <<-EOS
+Run options: {}
+
+# Running:
+
+      EOS
+
+      assert_equal exp_msg, io.string
+    end
+
+    def test_report_gives_test_run_statistics
+      reporter.start
+      reporter.record PassingTest.new.run
+      reporter.report
+
+      stats     = reporter.send :statistics
+      exp_stats = %r(Finished in 0{1,}.0{1,}s, 0{1,}.0{1,} runs/s, 0{1,}.0{1,} assertions/s.)
+
+      assert_match exp_stats, zeroify_time(stats)
+    end
+
+    def test_report_returns_errors
+      reporter.start
+      reporter.record FailingTest.new.run
+      reporter.report
+
+      aggregated_results     = reporter.send :aggregated_results
+      exp_aggregated_results = <<-EOS
+
+  1) Failure:
+Tunit::TestCase::FailingTest#test_fail [test/tunit/test_case.rb:LINE]:
+Failed assertion, no message given.
+
+      EOS
+
+      assert_equal exp_aggregated_results, remove_line_numbers(
+        truncate_absolut_path(aggregated_results)
+      )
+    end
+
+    def test_report_returns_summary
+      reporter.start
+      reporter.record PassingTest.new.run
+      reporter.report
+
+      summary     = reporter.send :summary
+      exp_summary = "1 runs, 1 assertions, 0 failures, 0 skips"
+
+      assert_equal exp_summary, summary
+    end
+
+    def test_report_considers_empty_test_failures
+      reporter.start
+      reporter.record FailingTest.new(:test_empty).run
+      reporter.report
+
+      summary     = reporter.send :summary
+      exp_summary = "1 runs, 0 assertions, 1 failures, 0 skips"
+
+      assert_equal exp_summary, summary
+    end
+
+    def test_report_summay_does_not_show_skip_message_if_verbose
+      reporter = SummaryReporter.new io, verbose: true
+      reporter.start
+      reporter.record SkippedTest.new.run
+      reporter.report
+
+      summary          = reporter.send :summary
+      summary_skip_msg = /#{SummaryReporter::SKIP_MSG}/
+
+      refute_match summary_skip_msg, summary
+    end
+
+    def test_report_only_shows_skips_if_verbose
+      unverbose_reporter    = self.reporter
+      unverbose_reporter.io = StringIO.new ""
+      verbose_reporter      = SummaryReporter.new io, verbose: true
+
+      verbose_reporter.start
+      verbose_reporter.record SkippedTest.new(:test_skip).run
+      verbose_reporter.report
+
+      reporter.start
+      reporter.record SkippedTest.new(:test_skip).run
+      reporter.report
+
+      exp_report = /1\) Skipped:\nTunit::TestCase::SkippedTest#test_skip \[(.*)\]/
+
+      assert_match exp_report, io.string
+      refute_match exp_report, reporter.io.string
+    end
+
+    private
+
+    def remove_line_numbers str
+      str.gsub(/:\d{1,}/, ':LINE')
+    end
+
+    def zeroify_time str
+      str.gsub(/\d/, '0')
+    end
+  end
+end

data/test/tunit/test_case.rb

@@ -0,0 +1,72 @@
+require "minitest/autorun"
+require "tunit/test"
+require "stringio"
+
+module Tunit
+  class TestCase < Minitest::Test
+    def io
+      @io ||= StringIO.new ""
+    end
+
+    def dummy_reporter
+      @dummy_reporter ||= Class.new {
+        def record(*)
+          @tests ||= 0
+          @tests += 1
+        end
+
+        def report(*)
+          @tests ||= 0
+          @tests
+        end
+      }.new
+    end
+
+    private
+
+    def truncate_absolut_path str
+      str.gsub(%r{\[.*(test/tunit/test_case.rb.*)\]}, '[\1]')
+    end
+
+    class PassingTest < Test
+      def initialize name = :test_pass
+        super
+      end
+
+      def test_pass
+        assert 2.even?
+      end
+
+      def test_pass_one_more
+        assert [1, 2].include?(2)
+      end
+    end
+
+    class FailingTest < Test
+      def initialize name = :test_fail
+        super
+      end
+
+      def test_fail
+        assert false
+      end
+
+      def test_empty
+      end
+    end
+
+    class SkippedTest < Test
+      def initialize test = :test_skip
+        super
+      end
+
+      def test_skip
+        skip
+      end
+
+      def test_skip_with_msg
+        skip "implement me when IQ > 80"
+      end
+    end
+  end
+end