kintama 0.1.1

data/test/matcher_test.rb

@@ -0,0 +1,65 @@
+require "test_helper"
+
+class MatcherTest < Test::Unit::TestCase
+
+  class EqualMatcher
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(provided_value)
+      @actual = provided_value
+      @actual == @expected
+    end
+
+    def failure_message
+      "Expected #{@expected}, but got #{@actual}"
+    end
+
+    def negative_failure_message
+      "Didn't expect #{@expected}, but got it anyway"
+    end
+
+    def description
+      "be equal to #{@expected.inspect}"
+    end
+  end
+
+  def test_should_allow_use_of_matchers_within_contexts
+    c = context "x" do
+      subject { 123 }
+      should EqualMatcher.new(456)
+    end
+    c.run
+    assert !c.passed?
+    assert_match /^Expected 456, but got 123/, c.failures.first.failure_message
+  end
+
+  def test_should_allow_negation_of_matchers
+    c = context "x" do
+      subject { 123 }
+      should_not EqualMatcher.new(123)
+    end
+    c.run
+    assert !c.passed?
+    assert_match /^Didn't expect 123, but got it anyway/, c.failures.first.failure_message
+  end
+
+  module MatcherExtension
+    def be_equal_to(expected)
+      EqualMatcher.new(expected)
+    end
+  end
+
+  def test_should_allow_definition_of_matchers_in_contexts
+    Kintama.extend(MatcherExtension)
+    c = context "x" do
+      subject { 'abc' }
+      should be_equal_to('abc')
+      should_not be_equal_to('def')
+    end
+    c.run
+    assert c.passed?
+    assert_equal ["should be equal to \"abc\"", "should not be equal to \"def\""], c.tests.map { |t| t.name }
+  end
+end

data/test/method_behaviour_test.rb

@@ -0,0 +1,176 @@
+require 'test_helper'
+
+class MethodBehaviourTest < Test::Unit::TestCase
+
+  def test_should_allow_methods_defined_in_the_context_to_be_called_in_tests
+    x = context "Given I ran a method" do
+      should "set something" do
+        assert self.respond_to?(:do_something)
+        assert_equal 123, do_something
+      end
+      def do_something
+        123
+      end
+    end
+    x.run
+    assert x.passed?
+  end
+
+  def test_should_allow_methods_defined_in_the_context_to_be_called_in_tests_in_subcontexts
+    x = context "Given I ran a method" do
+      context "in a subcontext" do
+        should "set something" do
+          assert self.respond_to?(:do_something)
+          assert_equal 234, do_something
+        end
+      end
+      def do_something
+        234
+      end
+    end
+    x.run
+    assert x.passed?
+  end
+
+  module MyStuff
+    def do_something
+      456
+    end
+  end
+
+  def test_should_be_able_to_call_methods_from_included_modules_in_tests
+    x = context "Given I include a module" do
+      include MyStuff
+      should "allow calling methods from that module" do
+        assert_equal 456, do_something
+      end
+    end
+    x.run
+    assert x.passed?
+  end
+
+  def test_should_not_allow_methods_from_one_context_to_bleed_into_another
+    context "Given I define a method in one context" do
+      def do_another_thing
+      end
+    end
+    x = context "And I define another context" do
+      it "should not be possible to call that method" do
+        assert !self.respond_to?(:do_another_thing)
+        assert_raises("should not be able to call this") { do_another_thing }
+      end
+    end
+    x.run
+    assert x.passed?
+  end
+
+  module MoreMyStuff
+    def get_thing
+      @thing
+    end
+  end
+
+  def test_should_allow_defined_methods_to_refer_to_instance_variables_defined_in_setup_when_included_via_modules
+    c = context "Given I define an instance variable in my setup" do
+      include MoreMyStuff
+      setup do
+        @thing = 123
+      end
+      should "be able to call a method that refers to that variable in a test" do
+        assert_equal 123, get_thing
+      end
+    end
+    c.run
+    assert c.passed?, "Thing was not defined!"
+  end
+
+  module DefaultBehaviour
+    def something
+      'abc'
+    end
+  end
+
+  def test_should_allow_including_default_behaviour_in_all_contexts
+    Kintama.include DefaultBehaviour
+    c = context "Given a context" do
+      should "be able to call a method from the globally shared behaviour" do
+        assert_equal 'abc', something
+      end
+    end
+    c.run
+    assert c.passed?, "something was not defined!"
+  end
+
+  def test_should_be_able_to_compose_shoulds_into_methods
+    $ran = false
+    x = context "Given a context" do
+      def self.should_create_a_should_from_a_method
+        should "have created this test" do
+          $ran = true
+          assert true
+        end
+      end
+
+      should_create_a_should_from_a_method
+    end
+    x.run
+    assert x.passed?
+    assert $ran
+
+    assert_not_nil x.should_have_created_this_test
+  end
+
+  def test_should_be_able_to_call_methods_in_subcontexts_that_create_tests
+    x = context "Given a subcontext" do
+      def self.with_a_method
+        should "create this test in the subcontext" do
+          flunk
+        end
+      end
+      context "which calls a method defined at the top level" do
+        with_a_method
+      end
+    end
+    x.run
+    subcontext = x.subcontexts.first
+    assert_equal ["should create this test in the subcontext"], subcontext.tests.map { |t| t.name }
+  end
+
+  module TestCreatingBehaviour
+    def with_a_method
+      should "create this test in the subcontext" do
+        flunk
+      end
+    end
+  end
+
+  def test_should_be_able_to_call_methods_in_subcontexts_that_create_tests_when_defined_in_modules
+    x = context "Given a subcontext" do
+      extend TestCreatingBehaviour
+
+      context "which calls a method defined at the top level" do
+        with_a_method
+      end
+    end
+    x.run
+    subcontext = x.subcontexts.first
+    assert_equal ["should create this test in the subcontext"], subcontext.tests.map { |t| t.name }
+  end
+
+  module NewKintamaBehaviour
+    def define_a_test
+      should "define a test" do
+        flunk
+      end
+    end
+  end
+
+  def test_should_be_able_to_add_behaviour_to_kintama
+    Kintama.extend NewKintamaBehaviour
+    x = context "A context" do
+      define_a_test
+    end
+    x.run
+    assert !x.passed?
+  end
+end

data/test/pending_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class PendingTest < Test::Unit::TestCase
+  
+  def test_should_pass_any_pending_tests
+    c = context "Given a context" do
+      test "that is not implemented"
+    end
+    c.run
+    assert c.passed?
+  end
+
+end

data/test/runners/base_runner_test.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+
+class BaseRunnerTest < Test::Unit::TestCase
+
+  def test_assert_output_works
+    assert_output("yes\n") do
+      puts "yes"
+    end
+  end
+
+  def test_should_print_summary_when_a_test_passes
+    c = context "given something" do
+      should "pass" do
+        assert true
+      end
+    end
+    r = runner(c)
+    capture_stdout { r.run }
+    assert_match /^1 tests, 0 failures/, r.test_summary
+  end
+
+  def test_should_print_out_summary_when_multiple_tests_pass
+    c = 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 }
+    assert_match /^2 tests, 0 failures/, r.test_summary
+  end
+
+  def test_should_print_out_summary_when_a_pending_test_exists
+    c = context "given something" do
+      should "pass" do
+        assert true
+      end
+      should "not be implemented yet"
+    end
+    r = runner(c)
+    capture_stdout { r.run }
+    assert_match /^2 tests, 0 failures, 1 pending/, r.test_summary
+  end
+
+  def test_should_print_out_failure_details_if_tests_fail
+    c = context "given something" do
+      should "fail" do
+        flunk
+      end
+      should "pass" do
+        assert true
+      end
+    end
+    r = runner(c)
+    capture_stdout { r.run }
+    assert_match /^1\) given something should fail:\n  flunked\./, r.failure_messages[0]
+  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 }
+    assert_match /^1 tests, 0 failures \(0\.\d+ seconds\)/, r.test_summary
+  end
+
+  def test_should_be_able_to_run_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
+    r = runner(c1, c2)
+    capture_stdout { r.run }
+    assert_match /^2 tests, 0 failures/, r.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
+    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
+    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, "should not have run the context twice"
+    end
+  end
+
+  def test_should_print_out_the_names_of_tests_that_fail
+    c = context "given something" do
+      should "fail" do
+        flunk
+      end
+    end
+    r = runner(c)
+    capture_stdout { r.run }
+    assert_match /^1\) given something should fail:\n  flunked\./, r.failure_messages[0]
+  end
+
+  def test_should_include_line_in_test_of_error_in_failure_message
+    c = context "given jazz" do
+      should "tapdance" do
+        $line = __LINE__; flunk
+      end
+    end
+    r = runner(c)
+    capture_stdout { r.run }
+    assert_match /at #{Regexp.escape(__FILE__)}:#{$line}/, r.failure_messages.first
+  end
+
+  private
+
+  def runner(*args)
+    Kintama::Runner::Base.new(*args)
+  end
+
+end

data/test/runners/inline_runner_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class InlineRunnerTest < Test::Unit::TestCase
+  def test_should_print_out_dots_when_a_test_passes
+    c = context "given something" do
+      should "pass" do
+        assert true
+      end
+    end
+    r = runner(c)
+    assert_output(/^\.\n/) do
+      r.run
+    end
+  end
+
+  def test_should_print_out_many_dots_as_tests_run
+    c = 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
+    end
+  end
+
+  def test_should_print_out_Fs_as_tests_fail
+    c = 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
+    end
+  end
+
+  def test_should_print_out_Ps_for_pending_tests
+    c = 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
+    end
+  end
+
+  private
+
+  def runner(*args)
+    Kintama::Runner::Inline.new(*args)
+  end
+end