kintama 0.1.9 → 0.2

data/test/usage/04_pending_tests_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class PendingTestsTest < KintamaIntegrationTest
+
+  def test_should_pass_any_pending_tests
+    context "Given a context with an unimplemented test" do
+      should "indicate that the test is not implemented" # NOTE - no test body
+    end.
+    should_output(%{
+      Given a context with an unimplemented test
+        should indicate that the test is not implemented: P
+    }).
+    and_pass
+  end
+
+end

data/test/usage/05_aliases_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class AliasesTest < KintamaIntegrationTest
+
+  def test_provides_given_alias_for_context
+    context "In a kintama test" do
+      given "a context that is defined using the `given` method" do
+        test "will be described using `given` in the output" do
+          assert true
+        end
+      end
+    end.
+    should_output(%{
+      In a kintama test
+        given a context that is defined using the `given` method
+          will be described using `given` in the output: .
+    })
+  end
+
+  def test_provides_testcase_alias_for_context
+    context "In a kintama test" do
+      testcase "a context defined using `testcase`" do
+        test "does not prefix anything to the context name" do
+          assert true
+        end
+      end
+    end.
+    should_output(%{
+      In a kintama test
+        a context defined using `testcase`
+          does not prefix anything to the context name: .
+    })
+  end
+
+  def test_provides_describe_alias_for_context
+    context "In a kintama test" do
+      describe "a context defined using `describe`" do
+        test "does not prefix anything to the context name" do
+          assert true
+        end
+      end
+    end.
+    should_output(%{
+      In a kintama test
+        a context defined using `describe`
+          does not prefix anything to the context name: .
+    })
+  end
+
+  def test_provides_should_alias_for_test
+    context "A context with a test defined using `should`" do
+      should "output the test with `should` in the name" do
+        assert true
+      end
+    end.
+    should_output(%{
+      A context with a test defined using `should`
+        should output the test with `should` in the name: .
+    })
+  end
+
+  def test_provides_it_alias_for_test
+    context "A context with a test defined using `it`" do
+      it "outputs the test with `it` in the name" do
+        assert true
+      end
+    end.
+    should_output(%{
+      A context with a test defined using `it`
+        it outputs the test with `it` in the name: .
+    })
+  end
+end

data/test/usage/06_defining_methods_in_tests_test.rb

@@ -0,0 +1,202 @@
+require 'test_helper'
+
+class DefiningMethodsInTestsTest < KintamaIntegrationTest
+
+  def test_should_allow_methods_defined_in_the_context_to_be_called_in_tests
+    context "Given a context with a method defined in it" do
+      def do_something
+        123
+      end
+
+      should "allow the method to be called within the test" do
+        assert self.respond_to?(:do_something)
+        assert_equal 123, do_something
+      end
+    end.
+    should_run_tests(1).
+    and_pass
+  end
+
+  def test_should_allow_methods_defined_in_the_context_to_be_called_in_tests_in_subcontexts
+    context "Given a method defined in the outer context" do
+      def do_something
+        234
+      end
+
+      context "in a subcontext" do
+        should "allow the method to be called" do
+          assert self.respond_to?(:do_something)
+          assert_equal 234, do_something
+        end
+      end
+    end.
+    should_run_tests(1).
+    and_pass
+  end
+
+  def test_should_not_allow_methods_from_one_context_to_bleed_into_another
+    context "Given some subcontexts" do
+      context "one of which contains a method" do
+        def do_another_thing
+          123
+        end
+
+        it "should be possible to call the method within the same subcontext" do
+          assert self.respond_to?(:do_another_thing)
+          assert_equal 123, do_another_thing
+        end
+      end
+
+      context "one of which does not contain that method" do
+        it "should not be possible to call the method defined in a different context" do
+          assert !self.respond_to?(:do_another_thing)
+          assert_raises("should not be able to call this") { do_another_thing }
+        end
+      end
+    end.
+    should_run_tests(2).
+    and_pass
+  end
+
+  module ModuleIncludedInContext
+    def method_from_module
+      456
+    end
+  end
+
+  def test_should_be_able_to_call_methods_from_included_modules_in_tests
+    context "Given a module included into a context" do
+      include ModuleIncludedInContext
+
+      should "allow calling methods from that module" do
+        assert_equal 456, method_from_module
+      end
+    end.
+    should_run_tests(1).
+    and_pass
+  end
+
+  module ModuleWithMethodReferencingAnInstanceVariable
+    def method_referencing_an_instance_variable
+      @thing
+    end
+  end
+
+  def test_should_allow_defined_methods_to_refer_to_instance_variables_defined_in_setup_when_included_via_modules
+    context "Given I define an instance variable in my setup" do
+      setup do
+        @thing = 123
+      end
+
+      include ModuleWithMethodReferencingAnInstanceVariable
+
+      should "be able to call a method that refers to that variable in a test" do
+        assert_equal 123, method_referencing_an_instance_variable
+      end
+    end.
+    should_run_tests(1).
+    and_pass "Thing was not defined!"
+  end
+
+  module ModuleIncludedIntoGlobalScope
+    def method_included_in_global_scope
+      'abc'
+    end
+  end
+
+  def test_should_allow_including_default_behaviour_in_all_contexts
+    Kintama.include ModuleIncludedIntoGlobalScope
+    context "Given a context" do
+      should "be able to call a method from the globally shared behaviour" do
+        assert_equal 'abc', method_included_in_global_scope
+      end
+    end.
+    should_run_tests(1).
+    and_pass "something was not defined!"
+  end
+
+  def test_should_be_able_to_compose_shoulds_into_methods
+    context "Given a context" do
+      def self.should_create_a_should_from_a_method
+        should "have created this test" do
+          assert true
+        end
+      end
+
+      should_create_a_should_from_a_method
+    end.
+    should_run_tests(1).
+    and_output(%{
+      Given a context
+        should have created this test: .
+    }).
+    and_pass
+  end
+
+  def test_should_be_able_to_call_methods_in_subcontexts_that_create_tests
+    context "Given a subcontext" do
+      def self.with_a_method
+        should "create this test in the subcontext" do
+          assert true
+        end
+      end
+
+      context "which calls a method defined at the top level" do
+        with_a_method
+      end
+    end.
+    should_run_tests(1).
+    and_output(%{
+      Given a subcontext
+        which calls a method defined at the top level
+          should create this test in the subcontext: .
+    }).
+    and_pass
+  end
+
+  module ModuleToAddBehaviourToContext
+    def method_to_define_test
+      should "create this test in the subcontext" do
+        assert true
+      end
+    end
+  end
+
+  def test_should_be_able_to_call_methods_in_subcontexts_that_create_tests_when_defined_in_modules
+    context "Given a subcontext" do
+      extend ModuleToAddBehaviourToContext
+
+      context "which calls a method defined at the top level" do
+        method_to_define_test
+      end
+    end.
+    should_run_tests(1).
+    and_output(%{
+      Given a subcontext
+        which calls a method defined at the top level
+          should create this test in the subcontext: .
+    }).
+    and_pass
+  end
+
+  module ModuleExtendedIntoGlobalScope
+    def method_to_define_a_test
+      should "define a test within the top-level-extended module" do
+        assert true
+      end
+    end
+  end
+
+  def test_should_be_able_to_add_behaviour_to_kintama
+    Kintama.extend ModuleExtendedIntoGlobalScope
+    context "A context that isn't explicitly extended by a module" do
+      method_to_define_a_test
+    end.
+    should_run_tests(1).
+    and_output(%{
+      A context that isn't explicitly extended by a module
+        should define a test within the top-level-extended module: .
+    }).
+    and_pass
+  end
+end

data/test/usage/07_exceptions_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class ExceptionsTest < KintamaIntegrationTest
+
+  def test_should_capture_exceptions_in_tests_as_failing_tests
+    context "Given a test" do
+      should "fail when there is an exception" do
+        raise "aaargh"
+      end
+    end.
+    should_run_tests(1).
+    and_fail
+  end
+
+  def test_should_capture_exceptions_in_setups_as_failing_tests
+    context "Given a test with setup that fails" do
+      setup do
+        raise "aargh"
+      end
+
+      should "fail even though it would otherwise pass" do
+        assert true
+      end
+    end.
+    should_run_tests(1).
+    and_fail
+  end
+
+  def test_should_capture_exceptions_in_teardowns_as_failing_tests
+    context "Given a test with teardown that fails" do
+      teardown do
+        raise "aargh"
+      end
+
+      should "fail even though it would otherwise pass" do
+        assert true
+      end
+    end.
+    should_run_tests(1).
+    and_fail
+  end
+end

data/test/usage/08_start_and_finish_test.rb

@@ -0,0 +1,261 @@
+require "test_helper"
+
+class StartAndFinishTest < KintamaIntegrationTest
+
+  def setup
+    super
+    @order = sequence('order')
+  end
+  attr_reader :order
+
+  def test_should_call_any_on_start_block_when_running_a_context
+    spy = test_spy
+
+    spy.expects(:in_startup).in_sequence(order)
+    spy.expects(:in_test).in_sequence(order)
+
+    context "A context with an `on_start` block" do
+      on_start do
+        spy.in_startup
+      end
+
+      should "have run the `on_start` block before a test" do
+        spy.in_test
+      end
+    end
+  end
+
+  def test_should_only_call_on_start_block_once_when_running_a_context
+    spy = test_spy
+
+    spy.expects(:in_startup).once.in_sequence(order)
+    spy.expects(:in_test).twice.in_sequence(order)
+
+    context "A context with an `on_start` block" do
+      on_start do
+        spy.in_startup
+      end
+
+      should "have run the `on_start` block before a test" do
+        spy.in_test
+      end
+
+      should "not run that block again before a second test" do
+        spy.in_test
+      end
+    end
+  end
+
+  def test_should_call_on_start_block_in_nested_contexts
+    spy = test_spy
+
+    spy.expects(:outer_startup).once.in_sequence(order)
+    spy.expects(:inner_startup).once.in_sequence(order)
+    spy.expects(:in_test).twice.in_sequence(order)
+
+    context "A context with an `on_start` block" do
+      on_start do
+        spy.outer_startup
+      end
+
+      context "and another `on_start` block in a nested context" do
+        on_start do
+          spy.inner_startup
+        end
+
+        should "have run both `on_start` blocks before running any tests" do
+          spy.in_test
+        end
+
+        should "not run either `on_start` blocks before running subsequent tests" do
+          spy.in_test
+        end
+      end
+    end
+  end
+
+  def test_should_call_any_on_finish_block_when_running_a_context
+    spy = test_spy
+
+    spy.expects(:in_test).in_sequence(order)
+    spy.expects(:in_finish).in_sequence(order)
+
+    context "A context with an `on_finish` block" do
+      should "not run the `on_finish` block before the test" do
+        spy.in_test
+      end
+
+      on_finish do
+        spy.in_finish
+      end
+    end
+  end
+
+  def test_should_only_call_on_finish_block_once_when_running_a_context
+    spy = test_spy
+
+    spy.expects(:in_test).twice.in_sequence(order)
+    spy.expects(:in_finish).once.in_sequence(order)
+
+    context "A context with an `on_finish` block" do
+      should "not be run after every test" do
+        spy.in_test
+      end
+
+      should "really not be run after every test" do
+        spy.in_test
+      end
+
+      on_finish do
+        spy.in_finish
+      end
+    end
+  end
+
+  def test_should_only_call_on_finish_block_after_all_tests
+    spy = test_spy
+
+    spy.expects(:in_test).times(3).in_sequence(order)
+    spy.expects(:in_finish).once.in_sequence(order)
+
+    context "A context with an `on_finish` block" do
+      should "have not run the `on_finish` block before the first test" do
+        spy.in_test
+      end
+
+      should "have not run the `on_finish` block before the second test" do
+        spy.in_test
+      end
+
+      should "have not run the `on_finish` block before the third test" do
+        spy.in_test
+      end
+
+      on_finish do
+        spy.in_finish
+      end
+    end
+  end
+
+  def test_should_call_on_finish_block_in_nested_contexts
+    spy = test_spy
+
+    spy.expects(:in_test).twice.in_sequence(order)
+    spy.expects(:inner_finish).once.in_sequence(order)
+    spy.expects(:outer_finish).once.in_sequence(order)
+
+    context "A context with an `on_finish` block" do
+      context "and another `on_finish` block in a nested context" do
+        should "not run either `on_finish` blocks before running the first test" do
+          spy.in_test
+        end
+
+        should "not run either `on_start` blocks before running subsequent tests" do
+          spy.in_test
+        end
+
+        on_finish do
+          spy.inner_finish
+        end
+      end
+
+      on_finish do
+        spy.outer_finish
+      end
+    end
+  end
+
+  def test_should_not_rely_on_any_ordering_to_register_on_start_or_on_finish_blocks
+    spy = test_spy
+
+    spy.expects(:on_start).in_sequence(order)
+    spy.expects(:in_test).in_sequence(order)
+    spy.expects(:on_finish).in_sequence(order)
+
+    context "A context with both an `on_start` and `on_finish` block" do
+      on_finish do
+        spy.on_finish
+      end
+
+      on_start do
+        spy.on_start
+      end
+
+      should "allow those blocks to be defined in any order, but run them correctly" do
+        spy.in_test
+      end
+    end
+  end
+
+  def test_should_be_able_to_use_rspec_like_aliases
+    spy = test_spy
+
+    spy.expects(:in_before_all).in_sequence(order)
+    spy.expects(:in_test).in_sequence(order)
+    spy.expects(:in_after_all).in_sequence(order)
+
+    context "A context with `before_all` and `after_all` blocks" do
+      before_all do
+        spy.in_before_all
+      end
+
+      should "run exactly as `on_start` and `on_finish` blocks" do
+        spy.in_test
+      end
+
+      after_all do
+        spy.in_after_all
+      end
+    end
+  end
+
+  def test_should_be_able_to_run_things_once_before_any_tests_run
+    spy = test_spy
+
+    spy.expects(:before_all_tests).once.in_sequence(order)
+    spy.expects(:in_test).twice.in_sequence(order)
+
+    Kintama.reset
+    Kintama.on_start do
+      spy.before_all_tests
+    end
+
+    running_default_context "A context" do
+      should "have run the `before_all_tests` block before a test" do
+        spy.in_test
+      end
+
+      should "only run `before_all_tests` once" do
+        spy.in_test
+      end
+    end
+  end
+
+  def test_should_be_able_to_run_things_after_all_tests_have_run
+    spy = test_spy
+
+    spy.expects(:in_test).twice.in_sequence(order)
+    spy.expects(:after_all_tests).once.in_sequence(order)
+
+    Kintama.reset
+    Kintama.on_finish do
+      spy.after_all_tests
+    end
+
+    running_default_context "A context" do
+      should "have run the `before_all_tests` block before a test" do
+        spy.in_test
+      end
+
+      should "only run `after_all_tests` once all tests have finished" do
+        spy.in_test
+      end
+    end
+  end
+
+  private
+
+  def test_spy
+    stub('test spy', poke: nil)
+  end
+end