kintama 0.1.1 → 0.1.3

data/README.md

@@ -149,21 +149,19 @@ You can also add (several) global `setup` and `teardown` blocks, which will be r
 Helpers
 -------
 
-If you want to make methods available in your tests, you have a few options. You can define them inline:
+If you want to make methods available in your tests, you can define them thusly:
 
     context "my face" do
       should "be awesome" do
         assert_equal "awesome", create_face.status
       end
 
-      helpers do
-        def create_face
-          Face.new(:name => "james", :eyes => "blue", :something => "something else")
-        end
+      def create_face
+        Face.new(:name => "james", :eyes => "blue", :something => "something else")
       end
     end
 
-Ideally I would've liked to make this syntatically similar to defining a private method in a class, but for various reasons that was not possible. Anyway, your other options are including a module:
+Your other options are including a module:
 
     module FaceHelper
       def create_face
@@ -180,33 +178,71 @@ Ideally I would've liked to make this syntatically similar to defining a private
 
 Or, if you're going to use the method in all your tests, you can add the module globally:
 
-    Kintama.add FaceHelper
+    Kintama.include FaceHelper
 
-or just define the method globally:
 
-    Kintama.add do
-      def create_face
-        # etc ...
-      end
-    end
+Extending
+---------
 
-### Aside: what happens if you do define a method in the context?
+If you want to add behaviour to Kintama itself (rather than to tests),
+you can use extend:
 
-It becomes available within context (and subcontext) definitions. Here's an example:
+    module Doing
+      def doing(&block)
+        @doing = block
+      end
 
-    context "blah" do
-      def generate_tests_for(thing)
-        it "should work with #{thing}" do
-          assert thing.works
+      def should_change(&block)
+        doing_block = @doing
+        should "change something" do
+          previous_value = instance_eval(&block)
+          instance_eval(&doing_block)
+          subsequent_value = instance_eval(&block)
+          assert subsequent_value != previous_value, "it didn't change"
         end
       end
 
-      [Monkey.new, Tiger.new].each do |t|
-        generate_tests_for(t)
+      def expect(name, &block)
+        doing_block = @doing
+        test "expects #{name}" do
+          instance_eval(&block)
+          instance_eval(&doing_block)
+        end
       end
     end
 
-This is a bit like defining a 'class method' in a `TestCase` and then being able to call it to generate contexts or tests within that `TestCase`. It's not that tricky once you get used to it.
+    class Thing
+      attr_reader :total
+      def initialize
+        @total = 0
+      end
+      def increment
+        @total += 1
+      end
+    end
+
+    context "Given something" do
+      extend Doing
+
+      setup { @thing = Thing.new }
+
+      doing { @thing.increment }
+
+      should_change { @thing.total }
+
+      # NOTE: this assumes Mocha is present
+      expect("increment to be called} { @thing.expects(:increment) }
+
+      # etc...
+    end
+
+As you can see, extending makes the method available at the context
+level, so it can be used to construct tests, new context types, and so
+on. This is really where the exciting stuff is.
+
+Oh, and of course, behaviour can be added to all tests as above:
+
+    Kintama.extend Doing
 
 
 And now, the more experimental stuff
@@ -244,4 +280,4 @@ Well... TO BE CONTINUED.
 [Tryouts]: https://github.com/delano/tryouts
 [Zebra]: https://github.com/jamesgolick/zebra
 [Shindo]: https://github.com/geemus/shindo
-[Exemplor]: https://github.com/quackingduck/exemplor
+[Exemplor]: https://github.com/quackingduck/exemplor

data/lib/kintama.rb

@@ -3,6 +3,7 @@ module Kintama
   autoload :Context, 'kintama/context'
   autoload :Test, 'kintama/test'
   autoload :TestFailure, 'kintama/test'
+  autoload :Reporter, 'kintama/reporter'
   autoload :Runner, 'kintama/runner'
   autoload :Assertions, 'kintama/assertions'
 
@@ -63,7 +64,7 @@ module Kintama
     # line or from within an editor
     def add_exit_hook
       return if @__added_exit_hook
-      at_exit { exit(Runner.default.run ? 0 : 1) }
+      at_exit { exit(Runner.from_args(ARGV, Kintama.default_context.subcontexts).run ? 0 : 1) }
       @__added_exit_hook = true
     end
 

data/lib/kintama/context.rb

@@ -18,6 +18,7 @@ module Kintama
         c = Class.new(parent)
         c.send(:include, Kintama::Context)
         c.name = name.to_s
+        c.definition = caller.find { |line| line =~ /^#{block.__file__}:(\d+)$/ }
         c.class_eval(&block)
         c
       end
@@ -45,7 +46,7 @@ module Kintama
         # redefine setup for the current set of blocks
         blocks = self.setup_blocks
         define_method(:setup) do
-          super
+          super()
           blocks.each { |b| instance_eval(&b) }
         end
       end
@@ -59,10 +60,28 @@ module Kintama
         blocks = self.teardown_blocks
         define_method(:teardown) do
           blocks.each { |b| instance_eval(&b) }
-          super
+          super()
         end
       end
 
+      def on_start_blocks
+        @on_start_blocks ||= []
+      end
+
+      def on_start(&block)
+        self.on_start_blocks << block
+      end
+      alias_method :before_all, :on_start
+
+      def on_finish_blocks
+        @on_finish_blocks ||= []
+      end
+
+      def on_finish(&block)
+        self.on_finish_blocks << block
+      end
+      alias_method :after_all, :on_finish
+
       # Defines the subject of any matcher-based tests.
       def subject(&block)
         define_method(:subject, &block)
@@ -73,6 +92,7 @@ module Kintama
         c = Class.new(self)
         c.send(:include, Kintama::Test)
         c.name = name
+        c.definition = caller.find { |line| line =~ /^[^:]+:(\d+)$/ }
         c.block = block if block_given?
       end
 
@@ -121,6 +141,10 @@ module Kintama
         children.select { |c| c.is_a_context? }.sort_by { |s| s.name }
       end
 
+      def all_runnables
+        tests + subcontexts + subcontexts.map { |s| s.all_runnables }.flatten
+      end
+
       # Returns true if this context has no known failed tests.
       def passed?
         failures.empty?
@@ -133,7 +157,7 @@ module Kintama
       end
 
       def pending
-        tests.select { |t| t.pending? } + subcontexts.map { |s| s.pending }.flatten
+        ran_tests.select { |t| t.pending? } + subcontexts.map { |s| s.pending }.flatten
       end
 
       def [](name)
@@ -164,15 +188,37 @@ module Kintama
 
       # Runs all tests in this context and any subcontexts.
       # Returns true if all tests passed; otherwise false
-      def run(runner=nil)
+      def run(reporter=nil)
+        run_tests(tests, true, reporter)
+      end
+
+      # Run a specific set of tests using the given the reporter
+      def run_tests(test_set, run_subcontexts, reporter)
         @ran_tests = []
-        runner.context_started(self) if runner
-        tests.each { |t| instance = t.new; instance.run(runner); ran_tests << instance }
-        subcontexts.each { |s| s.run(runner) }
-        runner.context_finished(self) if runner
+        reporter.context_started(self) if reporter
+        on_start_blocks.each { |b| instance_eval(&b) }
+        test_set.each { |t| instance = t.new; instance.run(reporter); ran_tests << instance }
+        subcontexts.each { |s| s.run(reporter) } if run_subcontexts
+        on_finish_blocks.each { |b| instance_eval(&b) }
+        reporter.context_finished(self) if reporter
         passed?
       end
 
+      def runnable_on_line(line)
+        sorted_runnables = all_runnables.delete_if { |r| r.line_defined.nil? }.sort_by { |r| r.line_defined }
+        if line >= sorted_runnables.first.line_defined
+          next_runnable = sorted_runnables.find { |r| r.line_defined > line }
+          index = sorted_runnables.index(next_runnable)
+          if index != nil && index > 0
+            sorted_runnables[index-1]
+          else
+            sorted_runnables.last
+          end
+        else
+          nil
+        end
+      end
+
       private
 
       def de_methodize(name)

data/lib/kintama/mocha.rb

@@ -0,0 +1,12 @@
+require "mocha"
+
+Kintama.include Mocha::API
+Kintama.teardown do
+  begin
+    mocha_verify
+  rescue Mocha::ExpectationError => e
+    raise e
+  ensure
+    mocha_teardown
+  end
+end

data/lib/kintama/reporter.rb

@@ -0,0 +1,146 @@
+module Kintama
+  class Reporter
+
+    def self.default
+      Verbose.new(colour=$stdin.tty?)
+    end
+
+    class Base
+      attr_reader :runner
+
+      def initialize
+        @test_count = 0
+      end
+
+      def started(runner)
+        @runner = runner
+        @start = Time.now
+      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 finished
+        @duration = Time.now - @start
+      end
+
+      def test_summary
+        output = ["#{@test_count} tests", "#{runner.failures.length} failures"]
+        output << "#{runner.pending.length} pending" if runner.pending.any?
+        output.join(", ") + " (#{format("%.4f", @duration)} seconds)"
+      end
+
+      def show_results
+        puts
+        puts test_summary
+        puts "\n" + failure_messages.join("\n\n") if runner.failures.any?
+      end
+
+      def failure_messages
+        x = 0
+        runner.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(colour=false)
+        super()
+        @colour = colour
+        @current_indent_level = 0
+      end
+
+      def indent
+        INDENT * @current_indent_level
+      end
+
+      def context_started(context)
+        print indent + context.name + "\n" if context.name
+        @current_indent_level += 1
+      end
+
+      def context_finished(context)
+        @current_indent_level -= 1
+        puts if @current_indent_level == 0 && context != runner.runnables.last
+      end
+
+      def test_started(test)
+        super
+        print 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 + 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/runnable.rb

@@ -1,10 +1,10 @@
 module Kintama
   class Runnable
     class << self
-      attr_accessor :name
+      attr_accessor :name, :definition
 
       def to_s
-        "<#{name} #{super}/#{is_a_test? ? 'Test' : 'Context'}>"
+        "<#{is_a_test? ? 'Test' : 'Context'}:#{name}>"
       end
 
       def is_a_test?
@@ -28,6 +28,10 @@ module Kintama
           nil
         end
       end
+
+      def line_defined
+        definition ? definition.split(":").last.to_i : nil
+      end
     end
   end
 end

data/lib/kintama/runner.rb

@@ -1,153 +1,77 @@
 module Kintama
   class Runner
-
-    def self.default
-      Verbose.new(*Kintama.default_context.subcontexts)
+    def self.from_args(args, runnables)
+      if args[0] == "--line"
+        Kintama::Runner::Line.new(args[1], runnables)
+      else
+        Kintama::Runner::Default.new(runnables)
+      end
     end
 
     class Base
-      def initialize(*contexts)
-        @contexts = contexts
-      end
+      attr_reader :runnables
 
-      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?
+      def initialize(runnables)
+        @runnables = runnables
       end
 
-      def context_started(context); end
-      def context_finished(context); end
-      def test_started(test)
-        @test_count += 1
+      def run(reporter=Kintama::Reporter.default, args=ARGV)
+        reporter.started(self)
+        @ran_runnables = run_tests(reporter)
+        reporter.finished
+        reporter.show_results
+        passed?
       end
-      def test_finished(test); end
 
       def passed?
         failures.empty?
       end
 
       def failures
-        @contexts.map { |c| c.failures }.flatten
+        @ran_runnables.map { |r| r.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
+        @ran_runnables.map { |r| r.pending }.flatten
       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)
+    # Runs every test provided as part of the constructor
+    class Default < Base
+      def run_tests(reporter)
+        @runnables.each do |r|
+          r.run(reporter)
         end
+        @runnables
       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)
+    # Runs only the test or context which contains the provided line
+    class Line < Base
+      def initialize(line, runnables)
+        super(runnables)
+        @line = line.to_i
+      end
+
+      def run_tests(reporter)
+        runnable = @runnables.map { |r| r.runnable_on_line(@line) }.compact.first
+        if runnable
+          if runnable.is_a_test?
+            heirarchy = []
+            parent = runnable.parent.parent
+            until parent == Kintama.default_context do
+              heirarchy.unshift parent
+              parent = parent.parent
+            end
+            heirarchy.each { |context| reporter.context_started(context) }
+            runnable.parent.run_tests([runnable], false, reporter)
+            [runnable.parent]
+          else
+            runnable.run(reporter)
+            [runnable]
+          end
         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

@@ -19,9 +19,9 @@ module Kintama
       base.send :attr_reader, :failure
     end
 
-    def run(runner=nil)
+    def run(reporter=nil)
       @failure = nil
-      runner.test_started(self) if runner
+      reporter.test_started(self) if reporter
       unless pending?
         begin
           setup
@@ -36,7 +36,7 @@ module Kintama
           end
         end
       end
-      runner.test_finished(self) if runner
+      reporter.test_finished(self) if reporter
       passed?
     end
 
@@ -57,12 +57,12 @@ module Kintama
     end
 
     def failure_message
-      "#{@failure.message} (at #{failure_line})"
+      "#{@failure.message}\n#{failure_backtrace}"
     end
 
-    def failure_line
+    def failure_backtrace
       base_dir = File.expand_path("../..", __FILE__)
-      @failure.backtrace.find { |line| File.expand_path(line).index(base_dir).nil? }
+      @failure.backtrace.select { |line| File.expand_path(line).index(base_dir).nil? }.map { |l| " "*4 + File.expand_path(l) }.join("\n")
     end
   end
 end

data/test/line_based_running_test.rb

@@ -0,0 +1,120 @@
+require "test_helper"
+
+class LineBasedRunningTest < Test::Unit::TestCase
+  def test_should_be_able_to_run_the_test_by_giving_the_line_number_the_test_is_defined_on
+    test_file = %{
+      context "given a thing" do
+        should "run this test" do
+          assert true
+        end
+        should "not run this test" do
+          flunk
+        end
+      end}
+    assert_match /^#{passing("should run this test")}\n\n1 tests/, run_test(test_file, "--line 3")
+    assert_match /^1 tests, 0 failures/, run_test(test_file, "--line 3")
+
+    assert_match /^#{failing("should not run this test")}\n\n1 tests/, run_test(test_file, "--line 6")
+    assert_match /^1 tests, 1 failures/, run_test(test_file, "--line 6")
+  end
+
+  def test_should_be_able_to_run_the_test_by_giving_the_line_number_within_the_test_definition
+    test_file = %{
+      context "given a thing" do
+        should "run this test" do
+          assert true
+        end
+        should "not run this test" do
+          flunk
+        end
+      end}
+    assert_match /^#{passing("should run this test")}\n\n1 tests/, run_test(test_file, "--line 4")
+    assert_match /^#{failing("should not run this test")}\n\n1 tests/, run_test(test_file, "--line 7")
+  end
+
+  def test_should_be_able_to_run_all_tests_within_a_context_when_line_falls_on_a_context
+    test_file = %{
+      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}
+    assert_match /#{passing("should run this test")}\n#{passing("should run this test too")}\n\n\n2 tests/, run_test(test_file, "--line 6")
+  end
+
+  def test_should_be_able_to_run_a_test_defined_in_a_second_top_level_context
+    test_file = %{
+      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}
+    assert_match /#{passing("should run this test")}\n\n\n1 tests/, run_test(test_file, "--line 8")
+  end
+
+  def test_should_print_out_the_full_nested_test_name
+    test_file = %{
+      context "given a test" do
+        context "that is nested deeply" do
+          should "print the full nesting name" do
+          end
+        end
+      end}
+    assert_match /given a test\n  that is nested deeply\n/, run_test(test_file, "--line 5")
+  end
+
+  def test_should_not_show_pending_tests_in_the_same_context_as_pending_when_not_targeted
+    test_file = %{
+      context "given a context with a pending test" do
+        should "only show the run test" do
+        end
+        should "ignore the pending test"
+      end}
+    assert_no_match /1 pending/, run_test(test_file, "--line 3")
+  end
+
+  private
+
+  def write_test(string, path)
+    f = File.open(path, "w") do |f|
+      f.puts %|$LOAD_PATH.unshift "#{File.expand_path("../../lib", __FILE__)}"; require "kintama"|
+      f.puts string.strip
+    end
+  end
+
+  def run_test(test_content, options)
+    path = "/tmp/kintama_tmp_test.rb"
+    write_test(test_content.strip, path)
+    prev = ENV["KINTAMA_EXPLICITLY_DONT_RUN"]
+    ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = nil
+    output = `ruby #{path} #{options}`
+    ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = prev
+    output
+  end
+
+  def passing(test_name)
+    if $stdin.tty?
+      /\e\[32m\s*#{test_name}\e\[0m/
+    else
+      /\s*#{test_name}: ./
+    end
+  end
+
+  def failing(test_name)
+    if $stdin.tty?
+      /\e\[31m\s*#{test_name}\e\[0m/
+    else
+      /\s*#{test_name}: F/
+    end
+  end
+end

data/test/{runners/base_runner_test.rb → reporters/base_reporter_test.rb}

@@ -1,6 +1,10 @@
 require 'test_helper'
 
-class BaseRunnerTest < Test::Unit::TestCase
+class BaseReporterTest < Test::Unit::TestCase
+
+  def setup
+    @reporter = Kintama::Reporter::Base.new
+  end
 
   def test_assert_output_works
     assert_output("yes\n") do
@@ -15,8 +19,8 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     r = runner(c)
-    capture_stdout { r.run }
-    assert_match /^1 tests, 0 failures/, r.test_summary
+    capture_stdout { r.run(@reporter) }
+    assert_match /^1 tests, 0 failures/, @reporter.test_summary
   end
 
   def test_should_print_out_summary_when_multiple_tests_pass
@@ -29,8 +33,8 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     r = runner(c)
-    capture_stdout { r.run }
-    assert_match /^2 tests, 0 failures/, r.test_summary
+    capture_stdout { r.run(@reporter) }
+    assert_match /^2 tests, 0 failures/, @reporter.test_summary
   end
 
   def test_should_print_out_summary_when_a_pending_test_exists
@@ -41,8 +45,8 @@ class BaseRunnerTest < Test::Unit::TestCase
       should "not be implemented yet"
     end
     r = runner(c)
-    capture_stdout { r.run }
-    assert_match /^2 tests, 0 failures, 1 pending/, r.test_summary
+    capture_stdout { r.run(@reporter) }
+    assert_match /^2 tests, 0 failures, 1 pending/, @reporter.test_summary
   end
 
   def test_should_print_out_failure_details_if_tests_fail
@@ -55,8 +59,8 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     r = runner(c)
-    capture_stdout { r.run }
-    assert_match /^1\) given something should fail:\n  flunked\./, r.failure_messages[0]
+    capture_stdout { r.run(@reporter) }
+    assert_match /^1\) given something should fail:\n  flunked\./, @reporter.failure_messages[0]
   end
 
   def test_should_print_out_the_test_duration
@@ -66,8 +70,8 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     r = runner(c)
-    capture_stdout { r.run }
-    assert_match /^1 tests, 0 failures \(0\.\d+ seconds\)/, r.test_summary
+    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
@@ -82,8 +86,8 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     r = runner(c1, c2)
-    capture_stdout { r.run }
-    assert_match /^2 tests, 0 failures/, r.test_summary
+    capture_stdout { r.run(@reporter) }
+    assert_match /^2 tests, 0 failures/, @reporter.test_summary
   end
 
   def test_should_return_true_if_all_tests_pass
@@ -92,7 +96,7 @@ class BaseRunnerTest < Test::Unit::TestCase
       should("also pass") { assert true }
     end
     capture_stdout do
-      assert_equal true, runner(c).run
+      assert_equal true, runner(c).run(@reporter)
     end
   end
 
@@ -102,7 +106,7 @@ class BaseRunnerTest < Test::Unit::TestCase
       should("fail") { flunk }
     end
     capture_stdout do
-      assert_equal false, runner(c).run
+      assert_equal false, runner(c).run(@reporter)
     end
   end
 
@@ -118,7 +122,7 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     capture_stdout do
-      assert runner(c).run, "should not have run the context twice"
+      assert runner(c).run(@reporter), "should not have run the context twice"
     end
   end
 
@@ -129,8 +133,8 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     r = runner(c)
-    capture_stdout { r.run }
-    assert_match /^1\) given something should fail:\n  flunked\./, r.failure_messages[0]
+    capture_stdout { r.run(@reporter) }
+    assert_match /^1\) given something should fail:\n  flunked\./, @reporter.failure_messages[0]
   end
 
   def test_should_include_line_in_test_of_error_in_failure_message
@@ -140,14 +144,14 @@ class BaseRunnerTest < Test::Unit::TestCase
       end
     end
     r = runner(c)
-    capture_stdout { r.run }
-    assert_match /at #{Regexp.escape(__FILE__)}:#{$line}/, r.failure_messages.first
+    capture_stdout { r.run(@reporter) }
+    assert_match /#{Regexp.escape(File.expand_path(__FILE__))}:#{$line}/, @reporter.failure_messages.first
   end
 
   private
 
   def runner(*args)
-    Kintama::Runner::Base.new(*args)
+    Kintama::Runner::Default.new(args)
   end
 
 end

data/test/{runners/inline_runner_test.rb → reporters/inline_reporter_test.rb}

@@ -1,6 +1,10 @@
 require 'test_helper'
 
-class InlineRunnerTest < Test::Unit::TestCase
+class InlineReporterTest < Test::Unit::TestCase
+  def setup
+    @reporter = Kintama::Reporter::Inline.new
+  end
+
   def test_should_print_out_dots_when_a_test_passes
     c = context "given something" do
       should "pass" do
@@ -9,7 +13,7 @@ class InlineRunnerTest < Test::Unit::TestCase
     end
     r = runner(c)
     assert_output(/^\.\n/) do
-      r.run
+      r.run(@reporter)
     end
   end
 
@@ -24,7 +28,7 @@ class InlineRunnerTest < Test::Unit::TestCase
     end
     r = runner(c)
     assert_output(/^\.\.\n/) do
-      r.run
+      r.run(@reporter)
     end
   end
 
@@ -39,7 +43,7 @@ class InlineRunnerTest < Test::Unit::TestCase
     end
     r = runner(c)
     assert_output(/^F\./) do
-      r.run
+      r.run(@reporter)
     end
   end
 
@@ -52,13 +56,13 @@ class InlineRunnerTest < Test::Unit::TestCase
     end
     r = runner(c)
     assert_output(/^P\./) do
-      r.run
+      r.run(@reporter)
     end
   end
 
   private
 
   def runner(*args)
-    Kintama::Runner::Inline.new(*args)
+    Kintama::Runner::Default.new(args)
   end
 end

data/test/{runners/verbose_runner_test.rb → reporters/verbose_reporter_test.rb}

@@ -1,6 +1,11 @@
 require 'test_helper'
 
-class VerboseRunnerTest < Test::Unit::TestCase
+class VerboseReporterTest < Test::Unit::TestCase
+
+  def setup
+    @reporter = Kintama::Reporter::Verbose.new(false)
+  end
+
   def test_should_print_out_test_names
     c = context "given something" do
       should "also pass" do
@@ -11,7 +16,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
       end
     end
     assert_output(/^given something\n  should also pass: \.\n  should pass: \./) do
-      runner(c).run(false)
+      runner(c).run(@reporter)
     end
   end
 
@@ -23,7 +28,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
       end
     end
     assert_output(/^given something\n  should not be implemented: P\n  should pass: \./) do
-      runner(c).run(false)
+      runner(c).run(@reporter)
     end
   end
 
@@ -44,7 +49,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
       end
     end
     assert_output(/^given something\n  should pass: \.\n  and something else\n    should pass: \.\n  and then this\n    should also pass: \./) do
-      runner(c).run(false)
+      runner(c).run(@reporter)
     end
   end
 
@@ -54,7 +59,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
         assert 1 == 2, "1 should equal 2"
       end
     end
-    assert_output(/given something should fail:\n  1 should equal 2/) { runner(c).run(false) }
+    assert_output(/given something should fail:\n  1 should equal 2/) { runner(c).run(@reporter) }
   end
 
   def test_should_print_out_a_summary_of_the_failing_tests_if_an_exception_occurs_in_a_test
@@ -63,7 +68,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
         raise "unexpected issue!"
       end
     end
-    assert_output(/given something should fail:\n  unexpected issue!/) { runner(c).run(false) }
+    assert_output(/given something should fail:\n  unexpected issue!/) { runner(c).run(@reporter) }
   end
 
   def test_should_print_out_a_summary_of_the_failing_tests_if_a_nested_test_fails
@@ -74,7 +79,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
         end
       end
     end
-    assert_output(/given something and something else should fail:\n  1 should equal 2/) { runner(c).run(false) }
+    assert_output(/given something and something else should fail:\n  1 should equal 2/) { runner(c).run(@reporter) }
   end
 
   def test_should_nest_verbose_output_properly_when_running_tests_from_several_contexts
@@ -89,7 +94,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
       end
     end
     assert_output(/^given something\n  should pass: \.\n\ngiven another thing\n  should also pass: \./) do
-      runner(c1, c2).run(false)
+      runner(c1, c2).run(@reporter)
     end
   end
 
@@ -104,7 +109,7 @@ class VerboseRunnerTest < Test::Unit::TestCase
       should "be yellow"
     end
     assert_output(/^given something\n\e\[32m  should be green\e\[0m\n\e\[31m  should be red\e\[0m\n\e\[33m  should be yellow\e\[0m/) do
-      runner(c).run(colour=true)
+      runner(c).run(Kintama::Reporter::Verbose.new(true))
     end
   end
 
@@ -117,13 +122,13 @@ class VerboseRunnerTest < Test::Unit::TestCase
       end
     end
     assert_output(/^In a world without hope\n  given a massive gun\n    it should work out well in the end: \./) do
-      runner(c).run(false)
+      runner(c).run(@reporter)
     end
   end
 
   private
 
   def runner(*args)
-    Kintama::Runner::Verbose.new(*args)
+    Kintama::Runner::Default.new(args)
   end
 end

data/test/start_and_finish_test.rb

@@ -0,0 +1,94 @@
+require "test_helper"
+
+class StartAndFinishTest < Test::Unit::TestCase
+  
+  def test_should_call_any_on_start_block_when_running_a_context
+    $ran = 0
+    c = context "A context with a startup block" do
+      on_start { $ran += 1 }
+      should "have run the on_start block" do
+      end
+    end
+    c.run
+    assert_equal 1, $ran
+  end
+
+  def test_should_only_call_on_start_block_once_when_running_a_context
+    $ran = 0
+    c = context "A context with a startup block" do
+      on_start { $ran += 1 }
+      should "have run the on_start block" do
+      end
+      should "not run that block again" do
+      end
+    end
+    c.run
+    assert_equal 1, $ran
+  end
+
+  def test_should_only_call_on_start_block_before_any_test
+    $ran = 0
+    c = context "A context with a startup block" do
+      on_start { $ran += 1 }
+      should "have run the on_start block" do
+        assert_equal 1, $ran
+      end
+      should "not run that block again" do
+        assert_equal 1, $ran
+      end
+    end
+    c.run
+    assert c.passed?
+  end
+
+  def test_should_call_any_on_finish_block_when_running_a_context
+    $ran = 0
+    c = context "A context with a startup block" do
+      should "have run the on_start block" do
+      end
+      on_finish { $ran += 1 }
+    end
+    c.run
+    assert_equal 1, $ran
+  end
+
+  def test_should_only_call_on_finish_block_once_when_running_a_context
+    $ran = 0
+    c = context "A context with a startup block" do
+      should "have run the on_start block" do
+      end
+      should "not run that block again" do
+      end
+      on_finish { $ran += 1 }
+    end
+    c.run
+    assert_equal 1, $ran
+  end
+
+  def test_should_only_call_on_finish_block_after_all_tests
+    $ran = 0
+    c = context "A context with a startup block" do
+      should "have run the on_start block" do
+        assert_equal 0, $ran
+      end
+      should "not run that block again" do
+        assert_equal 0, $ran
+      end
+      on_finish { $ran += 1 }
+    end
+    c.run
+    assert c.passed?
+  end
+
+  def test_should_be_able_to_use_rspec_like_aliases
+    $ran = 0
+    c = context "A context with a startup block" do
+      before_all { $ran += 1 }
+      should "have run the on_start block" do
+      end
+      after_all { $ran += 1 }
+    end
+    c.run
+    assert_equal 2, $ran
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kintama
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
+  hash: 29
+  prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - James Adam
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-05 00:00:00 +00:00
+date: 2011-04-04 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -34,18 +34,22 @@ files:
 - test/automatic_running_test.rb
 - test/exceptions_test.rb
 - test/kintama_test.rb
+- test/line_based_running_test.rb
 - test/matcher_test.rb
 - test/method_behaviour_test.rb
 - test/pending_test.rb
-- test/runners/base_runner_test.rb
-- test/runners/inline_runner_test.rb
-- test/runners/verbose_runner_test.rb
+- test/reporters/base_reporter_test.rb
+- test/reporters/inline_reporter_test.rb
+- test/reporters/verbose_reporter_test.rb
 - test/setup_test.rb
+- test/start_and_finish_test.rb
 - test/teardown_test.rb
 - test/test_and_subcontext_access_test.rb
 - test/test_helper.rb
 - lib/kintama/assertions.rb
 - lib/kintama/context.rb
+- lib/kintama/mocha.rb
+- lib/kintama/reporter.rb
 - lib/kintama/runnable.rb
 - lib/kintama/runner.rb
 - lib/kintama/test.rb
@@ -81,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.4.1
 signing_key: 
 specification_version: 3
 summary: It's for writing tests.