kintama 0.1.9 → 0.2

data/test/reporters/verbose_reporter_test.rb

@@ -1,147 +1,149 @@
 require 'test_helper'
 
-class VerboseReporterTest < Test::Unit::TestCase
-
-  def setup
-    @reporter = Kintama::Reporter::Verbose.new(false)
-  end
+class VerboseReporterTest < KintamaIntegrationTest
+  report_with Kintama::Reporter::Verbose
 
   def test_should_print_out_test_names
-    c = context "given something" do
-      should "also pass" do
+    context "given something" do
+      should "pass" do
         assert true
       end
-      should "pass" do
+      should "pass too" do
         assert true
       end
-    end
-    assert_output(/^given something\n  should also pass: \.\n  should pass: \./) do
-      runner(c).run(@reporter)
-    end
+    end.
+    should_output(%{
+      given something
+        should pass: .
+        should pass too: .
+    })
   end
 
   def test_should_print_out_Ps_beside_pending_test_names
-    c = context "given something" do
+    context "given something" do
       should "not be implemented"
       should "pass" do
         assert true
       end
-    end
-    assert_output(/^given something\n  should not be implemented: P\n  should pass: \./) do
-      runner(c).run(@reporter)
-    end
+    end.
+    should_output(%{
+      given something
+        should not be implemented: P
+        should pass: .
+    })
   end
 
   def test_should_nest_printed_context_and_test_names
-    c = context "given something" do
+    context "given something" do
       should "pass" do
         assert true
       end
-      context "and then this" do
-        should "also pass" do
+      context "and something else" do
+        should "pass" do
           assert true
         end
       end
-      context "and something else" do
-        should "pass" do
+      context "and then this" do
+        should "also pass" do
           assert true
         end
       end
-    end
-    assert_output(/^given something\n  should pass: \.\n  and something else\n    should pass: \.\n  and then this\n    should also pass: \./) do
-      runner(c).run(@reporter)
-    end
+    end.
+    should_output(%{
+      given something
+        should pass: .
+        and something else
+          should pass: .
+        and then this
+          should also pass: .
+    })
   end
 
   def test_should_print_out_a_summary_of_the_failing_tests_if_some_fail
-    c = context "given something" do
+    context "given something" do
       should "fail" do
         assert 1 == 2, "1 should equal 2"
       end
-    end
-    assert_output(/given something should fail:\n  1 should equal 2/) { runner(c).run(@reporter) }
+    end.
+    should_output(%{
+      given something should fail:
+        1 should equal 2
+    })
   end
 
   def test_should_print_out_a_summary_of_the_failing_tests_if_an_exception_occurs_in_a_test
-    c = context "given something" do
+    context "given something" do
       should "fail" do
         raise "unexpected issue!"
       end
-    end
-    assert_output(/given something should fail:\n  unexpected issue!/) { runner(c).run(@reporter) }
+    end.
+    should_output(%{
+      given something should fail:
+        unexpected issue!
+    })
   end
 
   def test_should_print_out_a_summary_of_the_failing_tests_if_a_nested_test_fails
-    c = context "given something" do
+    context "given something" do
       context "and something else" do
         should "fail" do
           assert 1 == 2, "1 should equal 2"
         end
       end
-    end
-    assert_output(/given something and something else should fail:\n  1 should equal 2/) { runner(c).run(@reporter) }
-  end
-
-  def test_should_nest_verbose_output_properly_when_running_tests_from_several_contexts
-    c1 = context "given something" do
-      should "pass" do
-        assert true
-      end
-    end
-    c2 = context "given another thing" do
-      should "also pass" do
-        assert true
-      end
-    end
-    assert_output(/^given something\n  should pass: \.\n\ngiven another thing\n  should also pass: \./) do
-      runner(c1, c2).run(@reporter)
-    end
+    end.
+    should_output(%{
+      given something and something else should fail:
+        1 should equal 2
+    })
   end
 
   def test_should_treat_a_context_as_transparent_if_it_has_no_name
-    c1 = context "given something" do
+    context "given something" do
       context do
         should "pass" do
           assert true
         end
       end
-    end
-    assert_output(/^given something\n  should pass: \./) do
-      runner(c1).run(@reporter)
-    end
+    end.
+    should_output(%{
+      given something
+        should pass: .
+    })
   end
 
   def test_should_print_out_test_names_in_colour_if_colour_is_set
-    c = context "given something" do
-      should "be red" do
+    use_colour = true
+    use_reporter Kintama::Reporter::Verbose.new(use_colour)
+
+    context "given tests reported in colour" do
+      should "show failures in red" do
         flunk
       end
-      should "be green" do
+      should "show passes in green" do
         assert true
       end
-      should "be yellow"
-    end
-    assert_output(/^given something\n\e\[32m  should be green\e\[0m\n\e\[31m  should be red\e\[0m\n\e\[33m  should be yellow\e\[0m/) do
-      runner(c).run(Kintama::Reporter::Verbose.new(true))
-    end
+      should "show pending tests in yellow"
+    end.
+    should_output(%{
+      given tests reported in colour
+      \e\[31m  should show failures in red\e\[0m
+      \e\[32m  should show passes in green\e\[0m
+      \e\[33m  should show pending tests in yellow\e\[0m
+    })
   end
 
   def test_should_print_appropriate_test_names_when_given_and_it_aliases_are_used
-    c = context "In a world without hope" do
+    context "In a world without hope" do
       given "a massive gun" do
         it "should work out well in the end" do
           assert true
         end
       end
-    end
-    assert_output(/^In a world without hope\n  given a massive gun\n    it should work out well in the end: \./) do
-      runner(c).run(@reporter)
-    end
-  end
-
-  private
-
-  def runner(*args)
-    Kintama::Runner::Default.new.with(*args)
+    end.
+    should_output(%{
+      In a world without hope
+        given a massive gun
+          it should work out well in the end: .
+    })
   end
-end
+end

data/test/test_helper.rb

@@ -1,12 +1,14 @@
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
-require 'test/unit'
+require 'bundler/setup'
+require 'minitest/autorun'
 
 ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = "true"
 require 'kintama'
 
 require 'stringio'
+require 'mocha/minitest'
 
-class Test::Unit::TestCase
+class Minitest::Test
   def setup
     Kintama.reset
   end
@@ -23,6 +25,13 @@ class Test::Unit::TestCase
     ensure
       $stdout = STDOUT
     end
+
+    def silence_stdout
+      $stdout = StringIO.new
+      return yield
+    ensure
+      $stdout = STDOUT
+    end
   end
 
   def assert_output(expected, &block)
@@ -34,3 +43,151 @@ class Test::Unit::TestCase
     end
   end
 end
+
+class KintamaIntegrationTest < Minitest::Test
+  class << self
+    def reporter_class
+      @reporter_class ||= Kintama::Reporter::Verbose
+    end
+
+    def report_with(reporter_class)
+      @reporter_class = reporter_class
+    end
+  end
+
+  attr_reader :reporter
+
+  private
+
+  def use_reporter(reporter)
+    @reporter = reporter
+  end
+
+  def context(name, &block)
+    ContextTestRunner.new(Kintama.context(name, &block), self)
+  end
+
+  def running_default_context(name, &block)
+    Kintama.context(name, &block)
+    ContextTestRunner.new(Kintama.default_context, self)
+  end
+
+  class ContextTestRunner
+    def initialize(context, test_unit_test)
+      @test_unit_test = test_unit_test
+      @context = context
+      @result = nil
+      use_colour = false
+      @reporter = @test_unit_test.reporter || test_unit_test.class.reporter_class.new(use_colour)
+      @output = capture_stdout do
+        @result = Kintama::Runner.default.with(context).run(@reporter)
+      end.read
+    end
+
+    def should_output(expected_output)
+      if expected_output.is_a?(Regexp)
+        processed_output = expected_output
+      else
+        processed_output = deindent_string_argument(expected_output)
+      end
+      @test_unit_test.assert_match processed_output, @output
+      self
+    end
+    alias_method :and_output, :should_output
+
+    def should_pass(message=nil)
+      @test_unit_test.assert(@result == true, message || "Expected a pass, but failed: #{@context.failures.map { |f| f.failure.message }.join(", ")}")
+      self
+    end
+    alias_method :and_pass, :should_pass
+
+    def should_fail(message=nil)
+      @test_unit_test.assert(@result == false, message || "Expected a failure, but passed!")
+      self
+    end
+    alias_method :and_fail, :should_fail
+
+    def with_failure(failure)
+      @test_unit_test.assert_match deindent_string_argument(failure), @output
+      self
+    end
+
+    def should_run_tests(number)
+      @test_unit_test.assert_equal number, @reporter.test_count, "Expected #{number} tests to run, but #{@reporter.test_count} actually did"
+      self
+    end
+
+    private
+
+    def deindent_string_argument(string)
+      initial_indent = string.gsub(/^\n/, '').match(/^(\s+)/)
+      initial_indent = initial_indent ? initial_indent[1] : ""
+      string.gsub("\n#{initial_indent}", "\n").gsub(/^\n/, '').gsub(/\s+$/, '')
+    end
+  end
+
+  def test_with_content(content)
+    IntegrationTestRunner.new(self, content)
+  end
+
+  class IntegrationTestRunner
+    def initialize(test_unit_test, test_body)
+      @test_unit_test = test_unit_test
+      @test_body = test_body
+    end
+
+    def run(options = nil, &block)
+      path = write_test(@test_body)
+      prev = ENV["KINTAMA_EXPLICITLY_DONT_RUN"]
+      ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = nil
+      @output = `ruby #{path} #{options}`
+      ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = prev
+      @exit_status = $?
+      instance_eval(&block) if block_given?
+      self
+    end
+
+    def should_have_passing_exit_status
+      @test_unit_test.assert_equal 0, @exit_status.exitstatus
+    end
+
+    def should_have_failing_exit_status
+      @test_unit_test.assert_equal 1, @exit_status.exitstatus
+    end
+
+    private
+
+    def assert_output(match)
+      @test_unit_test.assert_match(match, @output)
+    end
+
+    def refute_output(match)
+      @test_unit_test.refute_match(match, @output)
+    end
+
+    def passing(test_name)
+      if $stdin.tty?
+        /\e\[32m\s*#{test_name}\e\[0m/
+      else
+        /\s*#{test_name}: ./
+      end
+    end
+
+    def failing(test_name)
+      if $stdin.tty?
+        /\e\[31m\s*#{test_name}\e\[0m/
+      else
+        /\s*#{test_name}: F/
+      end
+    end
+
+    def write_test(string)
+      path = "/tmp/kintama_tmp_test.rb"
+      File.open(path, "w") do |f|
+        f.puts %|$LOAD_PATH.unshift "#{File.expand_path("../../lib", __FILE__)}"; require "kintama"|
+        f.puts string.strip
+      end
+      path
+    end
+  end
+end

data/test/{assertions_test.rb → unit/assertions_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class AssertionsTest < Test::Unit::TestCase
+class AssertionsTest < Minitest::Test
 
   class PseudoTest
     include Kintama::Assertions
@@ -40,7 +40,7 @@ class AssertionsTest < Test::Unit::TestCase
   end
 
   def test_should_provide_assert_kind_of
-    assert_passed { @test.assert_kind_of Fixnum, 1 }
+    assert_passed { @test.assert_kind_of Integer, 1 }
     assert_passed { @test.assert_kind_of Object, 1 }
     assert_passed { @test.assert_kind_of String, "hello" }
     assert_failed("pa!") { @test.assert_kind_of String, 1, "pa!" }
@@ -61,8 +61,13 @@ class AssertionsTest < Test::Unit::TestCase
   end
 
   def test_should_provide_assert_match
-    assert_passed { @test.assert_match /jam/, "bluejam" }
-    assert_failed(%|expected "blah" to match /mm/|) { @test.assert_match /mm/, "blah" }
+    assert_passed { @test.assert_match(/jam/, "bluejam") }
+    assert_failed(%|expected "blah" to match /mm/|) { @test.assert_match(/mm/, "blah") }
+  end
+
+  def test_should_provide_assert_no_match
+    assert_passed { @test.assert_no_match(/jam/, "bluejay") }
+    assert_failed(%|expected "blah" not to match /ah/|) { @test.assert_no_match(/ah/, "blah") }
   end
 
   def test_should_provide_assert_same_elements_to_compare_arrays
@@ -73,6 +78,50 @@ class AssertionsTest < Test::Unit::TestCase
     end
   end
 
+  def test_should_provide_assert_same
+    expected, actual = 'foo', 'foo'
+    assert_passed { @test.assert_same expected, expected }
+    assert_failed("Expected #{expected.inspect} (oid=#{expected.object_id}) to be the same as #{actual.inspect} (oid=#{actual.object_id})") do
+      @test.assert_same expected, actual
+    end
+  end
+
+  def test_should_provide_assert_output
+    assert_passed do
+      @test.assert_output 'foobar' do
+        puts 'foobar'
+      end
+    end
+    assert_passed do
+      @test.assert_output(/oba/) do
+        puts 'foobar'
+      end
+    end
+    assert_failed('Expected output to match "foobar"') do
+      @test.assert_output 'foobar' do
+        puts 'whambam'
+      end
+    end
+  end
+
+  def test_should_provide_assert_not_output
+    assert_passed do
+      @test.assert_not_output 'foobar' do
+        puts 'whambam'
+      end
+    end
+    assert_passed do
+      @test.assert_not_output(/oba/) do
+        puts 'whambam'
+      end
+    end
+    assert_failed('Expected output not to match "foobar"') do
+      @test.assert_not_output 'foobar' do
+        puts 'foobar'
+      end
+    end
+  end
+
   private
 
   def assert_passed
@@ -87,4 +136,4 @@ class AssertionsTest < Test::Unit::TestCase
       assert_equal message, e.message, "assertion failure message didn't match"
     end
   end
-end
+end