kintama 0.1.9 → 0.2

data/test/unit/context_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class ContextTest < Minitest::Test
+  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

data/test/unit/runner_test.rb

@@ -0,0 +1,87 @@
+require "test_helper"
+
+class RunnerTest < Minitest::Test
+  def setup
+    @reporter = Kintama::Reporter::Verbose.new(colour=false)
+  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
+    assert_equal true, silence_stdout { runner(c).run(@reporter) }
+  end
+
+  def test_should_return_false_if_any_tests_fails
+    c = context "given something" do
+      should("pass") { assert true }
+      should("fail") { flunk }
+    end
+    assert_equal false, silence_stdout { runner(c).run(@reporter) }
+  end
+
+  def test_should_be_able_to_run_tests_from_several_contexts
+    reporter = stub_reporter
+
+    reporter.expects(:test_started).twice
+
+    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
+    r = runner(c1, c2)
+    silence_stdout { r.run(reporter) }
+  end
+
+  def test_should_only_run_each_context_once
+    c = context "Given something" do
+      context "and a thing" do
+        should "only run this once" do
+        end
+      end
+    end
+
+    reporter = stub_reporter
+    reporter.expects(:context_started).with(responds_with(:name, "and a thing")).once
+
+    silence_stdout { 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
+
+  private
+
+  def stub_reporter
+    reporter = stub('reporter')
+    [:started, :finished, :context_started, :context_finished,
+     :test_started, :test_finished, :show_results].each do |method|
+      reporter.stubs(method)
+    end
+    reporter
+  end
+
+  def runner(*args)
+    Kintama::Runner::Default.new.with(*args)
+  end
+end

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

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TestAndSubcontextAccessTest < Test::Unit::TestCase
+class TestAndSubcontextAccessTest < Minitest::Test
 
   def test_should_stash_all_defined_contexts_so_they_can_be_accessed_later
     c1 = context "Given some context" do
@@ -14,33 +14,6 @@ class TestAndSubcontextAccessTest < Test::Unit::TestCase
     assert_equal [c1, c2], Kintama.default_context.subcontexts
   end
 
-  def test_should_allow_running_of_specific_subcontexts
-    x = context "Given something" do
-      should "not be run" do
-        flunk
-      end
-      context "and another thing" do
-        should "pass" do
-          assert true
-        end
-      end
-    end
-    inner_context = x.and_another_thing
-    inner_context.run
-    assert inner_context.passed?
-  end
-
-  def test_should_allow_running_of_specific_tests
-    x = context "Given something" do
-      should "fail when run" do
-        flunk
-      end
-    end
-    t = x.should_fail_when_run.new
-    t.run
-    assert !t.passed?
-  end
-
   def test_should_allow_running_of_specific_subcontexts_using_hashlike_syntax
     x = context "Given something" do
       should "not be run" do
@@ -76,7 +49,7 @@ class TestAndSubcontextAccessTest < Test::Unit::TestCase
         end
       end
     end
-    assert_equal true, x.and_another_thing.run
+    assert_equal true, x['and another thing'].run
   end
 
   def test_should_return_true_if_running_a_test_passes
@@ -85,7 +58,7 @@ class TestAndSubcontextAccessTest < Test::Unit::TestCase
         assert true
       end
     end
-    assert_equal true, x.should_pass_when_run.run
+    assert_equal true, x['should pass when run'].run
   end
 
   def test_should_return_false_if_running_a_subcontext_fails
@@ -96,7 +69,7 @@ class TestAndSubcontextAccessTest < Test::Unit::TestCase
         end
       end
     end
-    assert_equal false, x.and_another_thing.run
+    assert_equal false, x['and another thing'].run
   end
 
   def test_should_return_false_if_running_a_test_fails
@@ -105,6 +78,6 @@ class TestAndSubcontextAccessTest < Test::Unit::TestCase
         flunk
       end
     end
-    assert_equal false, x.should_fail_when_run.run
+    assert_equal false, x['should fail when run'].run
   end
-end
+end

data/test/usage/01_basic_usage_test.rb

@@ -0,0 +1,131 @@
+require 'test_helper'
+
+class BasicUsageTest < KintamaIntegrationTest
+
+  def test_should_pass_when_all_tests_pass
+    context "Given a test that passes" do
+      should "pass this test" do
+        assert true
+      end
+
+      should "pass this test too" do
+        assert true
+      end
+    end.
+    should_output(%{
+      Given a test that passes
+        should pass this test: .
+        should pass this test too: .
+    }).
+    and_pass
+  end
+
+  def test_should_fail_when_all_tests_fail
+    context "Given a test that fails" do
+      should "fail the test" do
+        flunk
+      end
+    end.
+    should_output(%{
+      Given a test that fails
+        should fail the test: F
+    }).
+    and_fail
+  end
+
+  def test_should_fail_when_any_tests_fail
+    context "Given two tests" do
+      should "pass the passing test" do
+        assert true
+      end
+
+      should "ultimately fail because there is one failing test" do
+        flunk
+      end
+    end.
+    should_run_tests(2).
+    and_fail.
+    with_failure("should ultimately fail because there is one failing test")
+  end
+
+  def test_should_fail_when_any_assertion_within_a_test_fails
+    context "Given a test with two assertions" do
+      should "fail because one of the assertions doesn't pass" do
+        assert 1 == 2
+        assert true
+      end
+    end.
+    should_run_tests(1).
+    and_fail
+  end
+
+  def test_should_not_run_any_code_beyond_a_failing_assertion
+    context "Given a test with a failure before the end of the test" do
+      should "not execute any test after the test failures" do
+        flunk "fail here"
+        raise "should not get here!"
+      end
+    end.
+    should_fail.with_failure("fail here")
+  end
+
+  def test_should_allow_nesting_of_contexts
+    context "Given a context" do
+      context "and a subcontext" do
+        should "nest this test within the inner context" do
+          assert true
+        end
+      end
+    end.
+    should_output(%{
+      Given a context
+        and a subcontext
+          should nest this test within the inner context: .
+    }).
+    and_pass
+  end
+
+  def test_should_allow_multiple_subcontexts
+    context "Given some contexts" do
+      context "one containing failing tests" do
+        should "ultimately fail because of the failing test" do
+          flunk
+        end
+      end
+
+      context "one containing passing tests" do
+        should "still run the passing test" do
+          assert true
+        end
+      end
+    end.
+    should_run_tests(2).
+    and_output(%{
+      Given some contexts
+        one containing failing tests
+          should ultimately fail because of the failing test: F
+        one containing passing tests
+          should still run the passing test: .
+    }).
+    and_fail
+  end
+
+  def test_should_allow_deep_nesting_of_subcontexts
+    context "Given something" do
+      context "and another thing" do
+        context "and one more thing" do
+          should "work" do
+            assert true
+          end
+        end
+      end
+    end.
+    should_output(%{
+      Given something
+        and another thing
+          and one more thing
+            should work: .
+    }).
+    and_pass
+  end
+end

data/test/usage/02_setup_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+
+class SetupTest < KintamaIntegrationTest
+
+  def test_should_allow_setup_to_provide_instance_variables
+    context "When setup sets an instance variable" do
+      setup do
+        @name = "james"
+      end
+
+      should "provide access to that instance variable in the test" do
+        assert_equal "james", @name
+      end
+    end.
+    should_run_tests(1).
+    and_pass
+  end
+
+  def test_should_call_all_setup_methods_when_running_tests_in_a_nested_context
+    context "Given a setup block in the outer context" do
+      setup do
+        @name = "james"
+      end
+
+      context "and another setup block in the inner context" do
+        setup do
+          @name += " is amazing"
+        end
+
+        should "run both setup blocks before the test" do
+          assert_equal "james is amazing", @name
+        end
+      end
+    end.
+    should_run_tests(1).
+    and_pass
+  end
+
+  def test_should_only_run_necessary_setups_where_tests_at_different_nestings_exist
+    context "Given a setup in the outer context" do
+      setup do
+        @name = "james"
+      end
+
+      context "and another setup in the inner context" do
+        setup do
+          @name += " is amazing"
+        end
+
+        should "run both setups for tests in the inner context" do
+          assert_equal "james is amazing", @name
+        end
+      end
+
+      should "only run the outer setup for tests in the outer context" do
+        assert_equal "james", @name
+      end
+    end.
+    should_run_tests(2).
+    and_pass
+  end
+
+  def test_should_run_setup_defined_on_kintama_itself_before_other_setups
+    Kintama.setup do
+      @thing = 'abc'
+    end
+
+    context "Given a context with a setup block" do
+      setup do
+        @thing += ' easy as 123'
+      end
+
+      should "have run the setup defined in the default behaviour before the context setup" do
+        assert_equal 'abc easy as 123', @thing
+      end
+    end.
+    should_run_tests(1).
+    and_pass
+  end
+
+  def test_should_allow_multiple_setups_to_be_registered
+    context "Given a context with multiple setup blocks" do
+      setup do
+        @name ||= "James"
+      end
+
+      setup do
+        @name += " Bond"
+      end
+
+      should "run them all in order" do
+        assert_equal "James Bond", @name
+      end
+    end.
+    should_run_tests(1).
+    and_pass
+  end
+end

data/test/usage/03_teardown_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+class TeardownTest < KintamaIntegrationTest
+
+  def setup
+    super
+    @order = sequence('teardown order')
+  end
+  attr_reader :order
+
+  def test_should_run_teardown_after_the_test_finishes
+    spy = teardown_spy
+    spy.expects(:in_test).once.in_sequence(order)
+    spy.expects(:tore_down).once.in_sequence(order)
+
+    context "Given a context with a teardown block" do
+      teardown do
+        spy.tore_down
+      end
+
+      should "run teardown after the test runs" do
+        spy.in_test
+      end
+    end
+  end
+
+  def test_should_run_all_teardowns_in_proximity_of_nesting_order_after_a_nested_test_finishes
+    spy = teardown_spy
+    spy.expects(:tore_down).with(:inner).in_sequence(order)
+    spy.expects(:tore_down).with(:outer).in_sequence(order)
+
+    context "Given a context with a teardown block" do
+      teardown do
+        spy.tore_down(:outer)
+      end
+
+      context "with a subcontext with another teardown block" do
+        teardown do
+          spy.tore_down(:inner)
+        end
+
+        should "run the inner and then outer teardowns after this test" do
+        end
+      end
+    end
+  end
+
+  def test_should_run_teardown_defined_on_kintama_itself_after_other_teardowns
+    spy = teardown_spy
+    spy.expects(:tore_down).with(:context_teardown).in_sequence(order)
+    spy.expects(:tore_down).with(:kintama_global_teardown).in_sequence(order)
+
+    Kintama.teardown do
+      spy.tore_down(:kintama_global_teardown)
+    end
+
+    context "Given a context with a teardown block" do
+      should "run the context teardown, and then the kintama global teardown" do
+      end
+
+      teardown do
+        spy.tore_down(:context_teardown)
+      end
+    end
+  end
+
+  def test_should_allow_multiple_teardowns_to_be_registered
+    spy = teardown_spy
+    spy.expects(:tore_down).with(:first_teardown).in_sequence(order)
+    spy.expects(:tore_down).with(:second_teardown).in_sequence(order)
+
+    context "Given a context with multiple teardown blocks" do
+      should "run them all in the order they appear" do
+        assert true
+      end
+
+      teardown do
+        spy.tore_down(:first_teardown)
+      end
+
+      teardown do
+        spy.tore_down(:second_teardown)
+      end
+    end
+  end
+
+  def test_should_run_teardowns_even_after_exceptions_in_tests
+    spy = teardown_spy
+    spy.expects(:tore_down)
+
+    context "Given a test that fails" do
+      should "still run teardown" do
+        raise "BOOM"
+      end
+
+      teardown do
+        spy.tore_down
+      end
+    end
+  end
+
+  def test_should_not_mask_exceptions_in_tests_with_ones_in_teardown
+    context "Given a test and teardown that fails" do
+      should "report the error in the test" do
+        raise "exception from test"
+      end
+
+      teardown do
+        raise "exception from teardown"
+      end
+    end.
+    should_fail.
+    with_failure("exception from test")
+  end
+
+  private
+
+  def teardown_spy
+    stub('teardown spy', tore_down: nil)
+  end
+end