kintama 0.1.9 → 0.2

data/lib/kintama/runnable.rb

@@ -22,7 +22,7 @@ module Kintama
 
       # Returns the full name of this context, taking any parent contexts into account
       def full_name
-        if @name
+        if instance_variable_defined?(:@name) && @name
           [parent ? parent.full_name : nil, @name].compact.join(" ")
         else
           nil
@@ -34,4 +34,4 @@ module Kintama
       end
     end
   end
-end
+end

data/lib/kintama/runner.rb

@@ -58,15 +58,15 @@ module Kintama
         runnable = @runnables.map { |r| r.runnable_on_line(@line) }.compact.first
         if runnable
           if runnable.is_a_test?
-            heirarchy = []
+            hierarchy = []
             parent = runnable.parent.parent
             until parent == Kintama.default_context do
-              heirarchy.unshift parent
+              hierarchy.unshift parent
               parent = parent.parent
             end
-            heirarchy.each { |context| reporter.context_started(context) }
+            hierarchy.each { |context| reporter.context_started(context) }
             runnable.parent.run_tests([runnable], false, reporter)
-            heirarchy.reverse.each { |context| reporter.context_finished(context) }
+            hierarchy.reverse.each { |context| reporter.context_finished(context) }
             [runnable.parent]
           else
             runnable.run(reporter)
@@ -74,7 +74,7 @@ module Kintama
           end
         else
           puts "Nothing runnable found on line #{@line}"
-          exit -1
+          exit(-1)
         end
       end
     end

data/lib/kintama/test.rb

@@ -9,7 +9,7 @@ module Kintama
         attr_accessor :block
 
         def pending?
-          @block.nil?
+          !instance_variable_defined?(:@block) || @block.nil?
         end
 
         def run
@@ -65,4 +65,4 @@ module Kintama
       @failure.backtrace.select { |line| File.expand_path(line).index(base_dir).nil? }.map { |l| " "*4 + File.expand_path(l) }.join("\n")
     end
   end
-end
+end

data/test/integration/automatic_running_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class AutomaticRunningTest < KintamaIntegrationTest
+
+  def test_should_be_able_to_run_kintama_tests_automatically_when_file_is_loaded
+    test_with_content(%{
+      context "given a thing" do
+        should "work" do
+          assert true
+        end
+      end
+    }).run.should_have_passing_exit_status
+
+    test_with_content(%{
+      context "given a thing" do
+        should "not work" do
+          flunk
+        end
+      end
+    }).run.should_have_failing_exit_status
+  end
+end

data/test/integration/line_based_running_test.rb

@@ -0,0 +1,129 @@
+require "test_helper"
+
+class LineBasedRunningTest < KintamaIntegrationTest
+  def test_should_be_able_to_run_the_test_by_giving_the_line_number_the_test_is_defined_on
+    test = test_with_content(%{
+      context "given a thing" do
+        should "run this test" do
+          assert true
+        end
+        should "not run this test" do
+          flunk
+        end
+      end
+    })
+    test.run('--line 3') do
+      assert_output(/^#{passing("should run this test")}\n\n1 tests/)
+      assert_output(/^1 tests, 0 failures/)
+    end
+    test.run('--line 6') do
+      assert_output(/^#{failing("should not run this test")}\n\n1 tests/)
+      assert_output(/^1 tests, 1 failures/)
+    end
+  end
+
+  def test_should_be_able_to_run_the_test_by_giving_the_line_number_within_the_test_definition
+    test = test_with_content(%{
+      context "given a thing" do
+        should "run this test" do
+          assert true
+        end
+        should "not run this test" do
+          flunk
+        end
+      end
+    })
+    test.run('--line 4') do
+      assert_output(/^#{passing("should run this test")}\n\n1 tests/)
+    end
+    test.run('--line 7') do
+      assert_output(/^#{failing("should not run this test")}\n\n1 tests/)
+    end
+  end
+
+  def test_should_be_able_to_run_all_tests_within_a_context_when_line_falls_on_a_context
+    test_with_content(%{
+      context "given a thing" do
+        should "not run this test" do
+          flunk
+        end
+        context "and another thing" do
+          should "run this test" do
+          end
+          should "run this test too" do
+          end
+        end
+      end
+    }).run('--line 6') do
+      assert_output(/#{passing("should run this test")}\n#{passing("should run this test too")}\n\n2 tests/)
+    end
+  end
+
+  def test_should_be_able_to_run_a_test_defined_in_a_second_top_level_context
+    test_with_content(%{
+      context "given a thing" do
+        should "not run this test" do
+          flunk
+        end
+      end
+      context "and another thing" do
+        should "run this test" do
+        end
+      end
+    }).run('--line 8') do
+      assert_output(/#{passing("should run this test")}\n\n1 tests/)
+    end
+  end
+
+  def test_should_print_out_the_full_nested_test_name
+    test_with_content(%{
+      context "given a test" do
+        context "that is nested deeply" do
+          should "print the full nesting name" do
+          end
+        end
+      end
+    }).run('--line 5') do
+      assert_output(/given a test\n  that is nested deeply\n/)
+    end
+  end
+
+  def test_should_not_show_pending_tests_in_the_same_context_as_pending_when_not_targeted
+    test_with_content(%{
+      context "given a context with a pending test" do
+        should "only show the run test" do
+        end
+        should "ignore the pending test"
+      end
+    }).run('--line 3') do
+      refute_output(/1 pending/)
+    end
+  end
+
+  def test_should_be_able_to_target_a_top_level_context
+  end
+
+  def test_should_run_all_tests_when_context_is_on_target_line
+    test_with_content(%{
+      context "given a context with a pending test" do
+        should "run this" do
+        end
+        should "run this too" do
+        end
+      end
+    }).run('--line 2') do
+      assert_output(/2 tests/)
+    end
+  end
+
+  def test_should_report_if_nothing_runnable_can_be_found_for_that_line
+    test_with_content(%{
+      context "given a short context" do
+        should "not run this" do
+        end
+      end
+    }).run('--line 1') do
+      assert_output(/Nothing runnable found on line 1/)
+    end
+  end
+end

data/test/reporters/base_reporter_test.rb

@@ -1,10 +1,7 @@
 require 'test_helper'
 
-class BaseReporterTest < Test::Unit::TestCase
-
-  def setup
-    @reporter = Kintama::Reporter::Base.new
-  end
+class BaseReporterTest < KintamaIntegrationTest
+  report_with Kintama::Reporter::Base
 
   def test_assert_output_works
     assert_output("yes\n") do
@@ -13,145 +10,78 @@ class BaseReporterTest < Test::Unit::TestCase
   end
 
   def test_should_print_summary_when_a_test_passes
-    c = context "given something" do
+    context "given something" do
       should "pass" do
         assert true
       end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^1 tests, 0 failures/, @reporter.test_summary
+    end.
+    should_output("1 tests, 0 failures")
   end
 
   def test_should_print_out_summary_when_multiple_tests_pass
-    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)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^2 tests, 0 failures/, @reporter.test_summary
+    end.
+    should_output("2 tests, 0 failures")
   end
 
   def test_should_print_out_summary_when_a_pending_test_exists
-    c = context "given something" do
+    context "given something" do
       should "pass" do
         assert true
       end
       should "not be implemented yet"
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^2 tests, 0 failures, 1 pending/, @reporter.test_summary
+    end.
+    should_output("2 tests, 0 failures, 1 pending")
   end
 
   def test_should_print_out_failure_details_if_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)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^1\) given something should fail:\n  flunked\./, @reporter.failure_messages[0]
+    end.
+    should_output(%{
+      1) given something should fail:
+        flunked
+    })
   end
 
   def test_should_print_out_the_test_duration
-    c = context "given something" do
-      should "pass" do
-        assert true
-      end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^1 tests, 0 failures \(0\.\d+ seconds\)/, @reporter.test_summary
-  end
-
-  def test_should_be_able_to_run_tests_from_several_contexts
-    c1 = context "given something" do
+    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
-    r = runner(c1, c2)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^2 tests, 0 failures/, @reporter.test_summary
-  end
-
-  def test_should_return_true_if_all_tests_pass
-    c = context "given something" do
-      should("pass") { assert true }
-      should("also pass") { assert true }
-    end
-    capture_stdout do
-      assert_equal true, runner(c).run(@reporter)
-    end
-  end
-
-  def test_should_return_false_if_any_tests_fails
-    c = context "given something" do
-      should("pass") { assert true }
-      should("fail") { flunk }
-    end
-    capture_stdout do
-      assert_equal false, runner(c).run(@reporter)
-    end
-  end
-
-  def test_should_only_run_each_context_once
-    Kintama.reset
-    $already_run = false
-    c = context "Given something" do
-      context "and a thing" do
-        should "only run this once" do
-          flunk if $already_run
-          $already_run = true
-        end
-      end
-    end
-    capture_stdout do
-      assert runner(c).run(@reporter), "should not have run the context twice"
-    end
+    end.
+    should_output(/^1 tests, 0 failures \(0\.\d+ seconds\)/)
   end
 
   def test_should_print_out_the_names_of_tests_that_fail
-    c = context "given something" do
+    context "given something" do
       should "fail" do
         flunk
       end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^1\) given something should fail:\n  flunked\./, @reporter.failure_messages[0]
+    end.
+    should_output(%{
+      1) given something should fail:
+        flunked
+    })
   end
 
   def test_should_include_line_in_test_of_error_in_failure_message
-    c = context "given jazz" do
-      should "tapdance" do
+    context "given a test that fails" do
+      should "report line of failing test" do
         $line = __LINE__; flunk
       end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /#{Regexp.escape(File.expand_path(__FILE__))}:#{$line}/, @reporter.failure_messages.first
+    end.
+    should_output(/#{Regexp.escape(File.expand_path(__FILE__))}:#{$line}/)
   end
-
-  private
-
-  def runner(*args)
-    Kintama::Runner::Default.new.with(*args)
-  end
-
-end
+end

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