kintama 0.1.11 → 0.1.12

data/test/reporters/inline_reporter_test.rb

@@ -1,68 +1,56 @@
 require 'test_helper'
 
-class InlineReporterTest < Test::Unit::TestCase
-  def setup
-    @reporter = Kintama::Reporter::Inline.new
-  end
+class InlineReporterTest < KintamaIntegrationTest
+  report_with Kintama::Reporter::Inline
 
   def test_should_print_out_dots_when_a_test_passes
-    c = context "given something" do
+    context "given something" do
       should "pass" do
         assert true
       end
-    end
-    r = runner(c)
-    assert_output(/^\.\n/) do
-      r.run(@reporter)
-    end
+    end.
+    should_output(%{
+      .
+    })
   end
 
   def test_should_print_out_many_dots_as_tests_run
-    c = context "given something" do
+    context "given something" do
       should "pass" do
         assert true
       end
       should "also pass" do
         assert true
       end
-    end
-    r = runner(c)
-    assert_output(/^\.\.\n/) do
-      r.run(@reporter)
-    end
+    end.
+    should_output(%{
+      ..
+    })
   end
 
   def test_should_print_out_Fs_as_tests_fail
-    c = context "given something" do
+    context "given something" do
       should "fail" do
         flunk
       end
       should "pass" do
         assert true
       end
-    end
-    r = runner(c)
-    assert_output(/^F\./) do
-      r.run(@reporter)
-    end
+    end.
+    should_output(%{
+      F.
+    })
   end
 
   def test_should_print_out_Ps_for_pending_tests
-    c = context "given something" do
+    context "given something" do
       should "not be implemented yet"
       should "pass" do
         assert true
       end
-    end
-    r = runner(c)
-    assert_output(/^P\./) do
-      r.run(@reporter)
-    end
-  end
-
-  private
-
-  def runner(*args)
-    Kintama::Runner::Default.new.with(*args)
+    end.
+    should_output(%{
+      P.
+    })
   end
-end
+end

data/test/reporters/verbose_reporter_test.rb

@@ -1,147 +1,148 @@
 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_reporter Kintama::Reporter::Verbose.new(colour=true)
+
+    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,10 +1,13 @@
+
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 require 'test/unit'
+require 'bundler/setup'
 
 ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = "true"
 require 'kintama'
 
 require 'stringio'
+require 'mocha/setup'
 
 class Test::Unit::TestCase
   def setup
@@ -23,6 +26,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 +44,85 @@ class Test::Unit::TestCase
     end
   end
 end
+
+class KintamaIntegrationTest < Test::Unit::TestCase
+  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
+      @reporter = @test_unit_test.reporter || test_unit_test.class.reporter_class.new(colour=false)
+      @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
+end

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

@@ -73,6 +73,14 @@ 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
+
   private
 
   def assert_passed

data/test/unit/context_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class ContextTest < Test::Unit::TestCase
+  def test_should_clear_previous_failure_when_running_test_again
+    $thing = 456
+    x = context "Given something" do
+      should "work" do
+        assert_equal 123, $thing
+      end
+    end
+    assert_equal false, x.run
+    $thing = 123
+    assert_equal true, x.run
+  end
+end