kintama 0.1.6 → 0.1.7

data/lib/kintama/assertions.rb

@@ -12,7 +12,7 @@ module Kintama
       assert actual == expected, message
     end
 
-    def assert_not_equal(expected, actual, message)
+    def assert_not_equal(expected, actual, message="Expected #{expected.inspect} to not be equal to #{actual.inspect}")
       assert actual != expected, message
     end
 
@@ -24,15 +24,37 @@ module Kintama
       assert_not_equal nil, object, message
     end
 
+    def assert_match(regexp, string, message="expected #{string.inspect} to match #{regexp.inspect}")
+      assert (string =~ regexp), message
+    end
+
     def assert_kind_of(klass, thing, message="should be a kind of #{klass}")
-      assert thing.is_a?(klass)
+      assert thing.is_a?(klass), message
+    end
+
+    def assert_nothing_raised(message="should not raise anything", &block)
+      yield
+    rescue Exception => e
+      raise Kintama::TestFailure, message + " (#{e} was raised)"
     end
 
-    def assert_raises(message="should raise an exception", &block)
+    def assert_raises(klass_or_message=Exception, message="should raise an exception", &block)
+      if klass_or_message.respond_to?(:ancestors)
+        klass = klass_or_message
+      else
+        message = klass_or_message
+        klass = Exception
+      end
       yield
-      raise Kintama::TestFailure, message
-    rescue
-      # do nothing, we expected this, but now no TestFailure was raised.
+      raised = false
+    rescue => e
+      if e.class.ancestors.include?(klass)
+        raised = true
+      else
+        raised = false
+      end
+    ensure
+      raise Kintama::TestFailure, message unless raised
     end
   end
 end

data/lib/kintama/context.rb

@@ -12,14 +12,47 @@ module Kintama
 
     module ClassMethods
 
+      def find_definition_1_8
+        line = caller.find { |line| line =~ /^[^:]+:(\d+)$/ }
+        if line
+          parts = line.split(":")
+          parts[1] = parts[1].to_i
+          parts
+        end
+      end
+
+      def find_definition_1_9(&block)
+        block.source_location if block
+      end
+
+      def find_definition_rbx(&block)
+        if block
+          m = block.block.code
+          [m.file, m.first_line]
+        end
+      end
+
+      def find_definition(&block)
+        if defined? RUBY_ENGINE
+          case RUBY_ENGINE
+          when "ruby"
+            RUBY_VERSION == "1.9.2" ? find_definition_1_9(&block) : find_definition_1_8
+          when "rbx"
+            find_definition_rbx(&block)
+          end
+        else
+          find_definition_1_8
+        end
+      end
+
       # Create a new context. If this is called within a context, a new subcontext
       # will be created. Aliases are 'testcase' and 'describe'
       def context(name=nil, parent=self, &block)
         c = Class.new(parent)
         c.send(:include, Kintama::Context)
         c.name = name.to_s if name
-        c.definition = caller.find { |line| line =~ /^#{block.__file__}:(\d+)$/ }
-        c.class_eval(&block)
+        c.definition = find_definition(&block)
+        c.class_eval(&block) if block
         c
       end
       alias_method :testcase, :context
@@ -94,7 +127,7 @@ module Kintama
         c = Class.new(self)
         c.send(:include, Kintama::Test)
         c.name = name
-        c.definition = caller.find { |line| line =~ /^[^:]+:(\d+)$/ }
+        c.definition = find_definition(&block)
         c.block = block if block_given?
       end
 
@@ -207,8 +240,9 @@ module Kintama
       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
+        known_runnables = all_runnables.delete_if { |r| r.line_defined.nil? }
+        sorted_runnables = known_runnables.sort_by { |r| r.line_defined }
+        if sorted_runnables.first && 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

data/lib/kintama/runnable.rb

@@ -30,7 +30,7 @@ module Kintama
       end
 
       def line_defined
-        definition ? definition.split(":").last.to_i : nil
+        definition ? definition.last : nil
       end
     end
   end

data/lib/kintama/test.rb

@@ -32,7 +32,7 @@ module Kintama
           begin
             teardown
           rescue Exception => e
-            @failure = e
+            @failure ||= e
           end
         end
       end

data/test/assertions_test.rb

@@ -10,33 +10,73 @@ class AssertionsTest < Test::Unit::TestCase
     @test = PseudoTest.new
   end
 
+  def test_should_provide_assert
+    assert_passed { @test.assert true }
+    assert_failed("waaa") { @test.assert false, "waaa" }
+  end
+
+  def test_should_provide_flunk
+    assert_failed(":(") { @test.flunk ":(" }
+  end
+
+  def test_should_provide_assert_equal
+    assert_passed { @test.assert_equal 1, 1 }
+    assert_failed("blurgh") { @test.assert_equal 1, 2, "blurgh" }
+  end
+
+  def test_should_provide_assert_not_equal
+    assert_passed { @test.assert_not_equal 1, 2 }
+    assert_failed("sadface") { @test.assert_not_equal 1, 1, "sadface" }
+  end
+
   def test_should_provide_assert_nil
-    assert_assertion_fails { @test.assert_nil Object.new }
-    assert_assertion_passes { @test.assert_nil nil }
+    assert_failed("bums") { @test.assert_nil Object.new, "bums" }
+    assert_passed { @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 }
+    assert_passed { @test.assert_not_nil Object.new }
+    assert_failed("fiddlesticks!") { @test.assert_not_nil nil, "fiddlesticks!" }
   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 }
+    assert_passed { @test.assert_kind_of Fixnum, 1 }
+    assert_passed { @test.assert_kind_of Object, 1 }
+    assert_passed { @test.assert_kind_of String, "hello" }
+    assert_failed("pa!") { @test.assert_kind_of String, 1, "pa!" }
+  end
+
+  def test_should_provide_assert_nothing_raised
+    assert_passed { @test.assert_nothing_raised { true } }
+    assert_passed { @test.assert_nothing_raised { false } }
+    assert_failed("ouch (oh no was raised)") { @test.assert_nothing_raised("ouch") { raise "oh no" } }
+  end
+
+  def test_should_provide_assert_raises
+    assert_passed { @test.assert_raises { raise "urgh" } }
+    assert_passed { @test.assert_raises(StandardError) { raise StandardError, "urgh" } }
+    assert_failed("no way") { @test.assert_raises("no way") { false } }
+    assert_failed { @test.assert_raises(RuntimeError) { raise StandardError, "urgh" } }
+    assert_passed { @test.assert_raises("woah") { this_method_doesnt_exist } }
+  end
+
+  def test_should_provide_assert_match
+    assert_passed { @test.assert_match /jam/, "bluejam" }
+    assert_failed(%|expected "blah" to match /mm/|) { @test.assert_match /mm/, "blah" }
   end
 
   private
 
-  def assert_assertion_passes
+  def assert_passed
     yield
   end
 
-  def assert_assertion_fails
+  def assert_failed(message=nil)
     yield
-    raise "assertion did not fail!"
-  rescue Kintama::TestFailure
-    # nothing
+    raise "assertion did not fail!" if failed
+  rescue Kintama::TestFailure => e
+    if message
+      assert_equal message, e.message, "assertion failure message didn't match"
+    end
   end
 end

data/test/line_based_running_test.rb

@@ -84,6 +84,8 @@ class LineBasedRunningTest < Test::Unit::TestCase
   end
 
   def test_should_be_able_to_target_a_top_level_context
+  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
@@ -94,7 +96,6 @@ class LineBasedRunningTest < Test::Unit::TestCase
       end}
     assert_match /2 tests/, run_test(test_file, "--line 2")
   end
-  end
 
   def test_should_report_if_nothing_runnable_can_be_found_for_that_line
     test_file = %{
@@ -105,22 +106,6 @@ class LineBasedRunningTest < Test::Unit::TestCase
     assert_match /Nothing runnable found on line 1/, run_test(test_file, "--line 1")
   end
 
-  def test_should_run_startup_blocks_from_outer_parents
-    test_file = %{
-      context "outer" do
-        on_start { $started = '123' }
-        context "inner" do
-          context "deeply inner" do
-            should "have run startup" do
-              assert_equal '123', $started
-            end
-          end
-        end
-      end}
-    assert_match /#{passing("should have run startup")}/, run_test(test_file, "--line 9")
-    assert_match /^1 tests, 0 failures/, run_test(test_file, "--line 9")
-  end
-
   private
 
   def write_test(string, path)

data/test/{pending_test.rb → pending_test_and_context.rb}

@@ -10,4 +10,11 @@ class PendingTest < Test::Unit::TestCase
     assert c.passed?
   end
 
+  def test_should_ignore_empty_contexts
+    c = context "Given an empty context" do
+      context "should ignore this"
+    end
+    c.run
+    assert c.passed?
+  end
 end

data/test/teardown_test.rb

@@ -89,4 +89,18 @@ class TeardownTest < Test::Unit::TestCase
     assert !c.passed?
     assert ran
   end
+
+  def test_should_not_mask_exceptions_in_tests_with_ones_in_teardown
+    c = context "Given a test that fails" do
+      should "report this error" do
+        raise "this"
+      end
+      teardown do
+        raise "that"
+      end
+    end
+    c.run
+    assert !c.passed?
+    assert_equal "this", c.failures.first.failure.to_s
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kintama
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 1
-  - 6
-  version: 0.1.6
+  - 7
+  version: 0.1.7
 platform: ruby
 authors: 
 - James Adam
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-29 00:00:00 +01:00
+date: 2011-06-01 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -37,7 +37,7 @@ files:
 - test/line_based_running_test.rb
 - test/matcher_test.rb
 - test/method_behaviour_test.rb
-- test/pending_test.rb
+- test/pending_test_and_context.rb
 - test/reporters/base_reporter_test.rb
 - test/reporters/inline_reporter_test.rb
 - test/reporters/verbose_reporter_test.rb