kintama 0.1.1

data/lib/kintama/runnable.rb

@@ -0,0 +1,33 @@
+module Kintama
+  class Runnable
+    class << self
+      attr_accessor :name
+
+      def to_s
+        "<#{name} #{super}/#{is_a_test? ? 'Test' : 'Context'}>"
+      end
+
+      def is_a_test?
+        ancestors.index(Kintama::Test) && 
+        ancestors.index(Kintama::Test) < ancestors.index(Kintama::Context)
+      end
+
+      def is_a_context?
+        !is_a_test?
+      end
+
+      def parent
+        superclass.ancestors.include?(Kintama::Context) ? superclass : nil
+      end
+
+      # Returns the full name of this context, taking any parent contexts into account
+      def full_name
+        if @name
+          [parent ? parent.full_name : nil, @name].compact.join(" ")
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/kintama/runner.rb

@@ -0,0 +1,153 @@
+module Kintama
+  class Runner
+
+    def self.default
+      Verbose.new(*Kintama.default_context.subcontexts)
+    end
+
+    class Base
+      def initialize(*contexts)
+        @contexts = contexts
+      end
+
+      def run(colour=$stdin.tty?)
+        @colour = colour
+        @test_count = 0
+        start = Time.now
+        @contexts.each do |c|
+          @current_indent = -1
+          c.run(self)
+          puts if c != @contexts.last
+        end
+        @duration = Time.now - start
+        show_results
+        passed?
+      end
+
+      def context_started(context); end
+      def context_finished(context); end
+      def test_started(test)
+        @test_count += 1
+      end
+      def test_finished(test); end
+
+      def passed?
+        failures.empty?
+      end
+
+      def failures
+        @contexts.map { |c| c.failures }.flatten
+      end
+
+      def pending
+        @contexts.map { |c| c.pending }.flatten
+      end
+
+      def test_summary
+        output = ["#{@test_count} tests", "#{failures.length} failures"]
+        output << "#{pending.length} pending" if pending.any?
+        output.join(", ") + " (#{format("%.4f", @duration)} seconds)"
+      end
+
+      def show_results
+        puts
+        puts test_summary
+        puts "\n" + failure_messages.join("\n\n") if failures.any?
+      end
+
+      def failure_messages
+        x = 0
+        failures.map do |test|
+          x += 1
+          "#{x}) #{test.full_name}:\n  #{test.failure_message}"
+        end
+      end
+
+      def character_status_of(test)
+        character = if test.pending?
+          'P'
+        elsif test.passed?
+          '.'
+        else
+          'F'
+        end
+      end
+    end
+
+    class Inline < Base
+      def test_finished(test)
+        print character_status_of(test)
+      end
+
+      def show_results
+        puts
+        super
+      end
+    end
+
+    class Verbose < Base
+      INDENT = "  "
+
+      def initialize(*contexts)
+        super
+        @current_indent = -1
+      end
+
+      def indent
+        INDENT * @current_indent
+      end
+
+      def context_started(context)
+        @current_indent += 1
+        print indent + context.name + "\n" if context.name
+      end
+
+      def context_finished(context)
+        @current_indent -= 1
+      end
+
+      def test_started(test)
+        super
+        print indent + INDENT + test.name + ": " unless @colour
+      end
+
+      def test_finished(test)
+        if @colour
+          puts coloured_name(test)
+        else
+          puts character_status_of(test)
+        end
+      end
+
+      private
+
+      def coloured_name(test)
+        test_name = indent + INDENT + test.name
+        if test.pending?
+          yellow(test_name)
+        elsif test.passed?
+          green(test_name)
+        else
+          red(test_name)
+        end
+      end
+
+      def color(text, color_code)
+        "#{color_code}#{text}\e[0m"
+      end
+
+      def green(text)
+        color(text, "\e[32m")
+      end
+
+      def red(text)
+        color(text, "\e[31m")
+      end
+
+      def yellow(text)
+        color(text, "\e[33m")
+      end
+    end
+
+  end
+end

data/lib/kintama/test.rb

@@ -0,0 +1,68 @@
+module Kintama
+  class TestFailure < StandardError; end
+
+  module Test
+    include Kintama::Assertions
+
+    def self.included(base)
+      class << base
+        attr_accessor :block
+
+        def pending?
+          @block.nil?
+        end
+
+        def run
+          new.run
+        end
+      end
+      base.send :attr_reader, :failure
+    end
+
+    def run(runner=nil)
+      @failure = nil
+      runner.test_started(self) if runner
+      unless pending?
+        begin
+          setup
+          instance_eval(&self.class.block)
+        rescue Exception => e
+          @failure = e
+        ensure
+          begin
+            teardown
+          rescue Exception => e
+            @failure = e
+          end
+        end
+      end
+      runner.test_finished(self) if runner
+      passed?
+    end
+
+    def pending?
+      self.class.pending?
+    end
+
+    def passed?
+      @failure.nil?
+    end
+
+    def name
+      self.class.name
+    end
+
+    def full_name
+      self.class.full_name
+    end
+
+    def failure_message
+      "#{@failure.message} (at #{failure_line})"
+    end
+
+    def failure_line
+      base_dir = File.expand_path("../..", __FILE__)
+      @failure.backtrace.find { |line| File.expand_path(line).index(base_dir).nil? }
+    end
+  end
+end

data/test/aliases_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class AliasesTest < Test::Unit::TestCase
+
+  def test_should_provide_given_and_it_aliases_for_context_and_should
+    x = 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
+    x.run
+    assert x.passed?
+  end
+
+  def test_should_provide_testcase_alias_for_context
+    x = testcase "In a world without hope" do
+      should "work out well in the end" do
+        assert true
+      end
+    end
+    x.run
+    assert x.passed?
+  end
+end

data/test/assertions_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class AssertionsTest < Test::Unit::TestCase
+
+  class PseudoTest
+    include Kintama::Assertions
+  end
+
+  def setup
+    @test = PseudoTest.new
+  end
+
+  def test_should_provide_assert_nil
+    assert_assertion_fails { @test.assert_nil Object.new }
+    assert_assertion_passes { @test.assert_nil nil }
+  end
+
+  def test_should_provide_assert_not_nil
+    assert_assertion_passes { @test.assert_not_nil Object.new }
+    assert_assertion_fails { @test.assert_not_nil nil }
+  end
+
+  def test_should_provide_assert_kind_of
+    assert_assertion_passes { @test.assert_kind_of Fixnum, 1 }
+    assert_assertion_passes { @test.assert_kind_of Object, 1 }
+    assert_assertion_passes { @test.assert_kind_of String, "hello" }
+    assert_assertion_fails { @test.assert_kind_of String, 1 }
+  end
+
+  private
+
+  def assert_assertion_passes
+    yield
+  end
+
+  def assert_assertion_fails
+    yield
+    raise "assertion did not fail!"
+  rescue Kintama::TestFailure
+    # nothing
+  end
+end

data/test/automatic_running_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class AutomaticRunningTest < Test::Unit::TestCase
+
+  def test_should_be_able_to_run_tests_automatically_when_file_is_loaded
+    assert_passes write_test %{
+      context "given a thing" do
+        should "work" do
+          assert true
+        end
+      end}
+    assert_fails write_test %{
+      context "given a thing" do
+        should "not work" do
+          flunk
+        end
+      end}
+  end
+
+  private
+
+  def write_test(string)
+    f = File.open("/tmp/kintama_tmp_test.rb", "w") do |f|
+      f.puts %|$LOAD_PATH.unshift "#{File.expand_path("../../lib", __FILE__)}"; require "kintama"|
+      f.puts string
+    end
+    "/tmp/kintama_tmp_test.rb"
+  end
+
+  def run_test(path)
+    prev = ENV["KINTAMA_EXPLICITLY_DONT_RUN"]
+    ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = nil
+    output = `ruby #{path}`
+    ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = prev
+    $?
+  end
+
+  def assert_passes(path)
+    assert_equal 0, run_test(path).exitstatus
+  end
+
+  def assert_fails(path)
+    assert_equal 1, run_test(path).exitstatus
+  end
+end

data/test/exceptions_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class ExceptionsTest < Test::Unit::TestCase
+
+  def test_should_capture_exceptions_in_tests_as_failing_tests
+    x = context "Given a test" do
+      should "that raises an exception" do
+        raise "aaargh"
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_capture_exceptions_in_setups_as_failing_tests
+    x = context "Given a test with setup that fails" do
+      setup do
+        raise "aargh"
+      end
+      should "that would otherwise pass" do
+        assert true
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_capture_exceptions_in_teardowns_as_failing_tests
+    x = context "Given a test with teardown that fails" do
+      teardown do
+        raise "aargh"
+      end
+      should "that would otherwise pass" do
+        assert true
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+end

data/test/kintama_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+class KintamaTest < Test::Unit::TestCase
+
+  def test_should_pass_when_all_tests_pass
+    x = context "Given something" do
+      should "work" do
+        assert true
+      end
+    end
+    x.run
+    assert x.passed?
+  end
+
+  def test_should_fail_when_all_tests_fail
+    x = context "Given something" do
+      should "work" do
+        flunk
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_fail_when_any_tests_fail
+    x = context "Given something" do
+      should "work" do
+        flunk
+      end
+      should "also work" do
+        assert true
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_fail_when_any_assertion_within_a_test_fails
+    x = context "Given something" do
+      should "ultimately not work" do
+        flunk
+        assert true
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_not_run_any_code_beyond_a_failing_assertion
+    x = context "Given something" do
+      should "ultimately not work" do
+        flunk
+        raise "should not get here!"
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_allow_nesting_of_contexts
+    x = context "Given something" do
+      context "and another thing" do
+        should "work" do
+          flunk
+        end
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_allow_multiple_subcontexts
+    x = context "Given something" do
+      context "and another thing" do
+        should "work" do
+          flunk
+        end
+      end
+      context "and another different thing" do
+        should "work" do
+          assert true
+        end
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  def test_should_allow_deep_nesting_of_subcontexts
+    x = context "Given something" do
+      context "and another thing" do
+        context "and one more thing" do
+          should "work" do
+            flunk
+          end
+        end
+      end
+    end
+    x.run
+    assert !x.passed?
+  end
+
+  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