kintama 0.1.11 → 0.1.12

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a59c25b77b6889c784049956601ab4ba2000c31
+  data.tar.gz: 8aefa27d4b0581ea3799f3c4faba2ae861a7cc5c
+SHA512:
+  metadata.gz: b4fd4b530520996ccc0a1014cc9146d2ea0a934e6d024d009e37fc0c9efb61271033463b87b890111d1e2d5aac38641fa2e76e197d79ffad196e68a53d37f9bd
+  data.tar.gz: 8c5c445a35e8243820690ba4fc2ee1944144ae779562c7b8d7d4305341c61e6e679a9b1a8841c65248dba1d50bc173450837507ae13957682211e23922c7258b

data/lib/kintama.rb

@@ -11,6 +11,10 @@ module Kintama
   autoload :Assertions, 'kintama/assertions'
 
   class << self
+    def no_conflict?
+      ENV["KINTAMA_NO_CONFLICT"]
+    end
+
     def reset
       @default_context = Class.new(Runnable)
       @default_context.send(:include, Kintama::Context)
@@ -43,6 +47,16 @@ module Kintama
       default_context.teardown(&block)
     end
 
+    def on_start(&block)
+      default_context.on_start(&block)
+    end
+    alias_method :before_all, :on_start
+
+    def on_finish(&block)
+      default_context.on_finish(&block)
+    end
+    alias_method :after_all, :on_finish
+
     # Makes behaviour available within tests:
     #
     #   module SomeModule
@@ -76,9 +90,7 @@ module Kintama
 
           opts.on("-r", "--reporter NAME",
                   "Use the given reporter (inline or verbose)") do |reporter|
-                  puts "reporter!"
             options.reporter = Kintama::Reporter.called(reporter)
-            p options.reporter
           end
           opts.on("-l", "--line LINE",
                   "Run the test or context on the given line") do |line|
@@ -127,9 +139,11 @@ module Kintama
   end
 end
 
-[:context, :given, :describe, :testcase].each do |method|
-  unless self.respond_to?(method)
-    eval %|def #{method}(*args, &block); Kintama.#{method}(*args, &block); end|
+unless Kintama.no_conflict?
+  [:context, :given, :describe, :testcase].each do |method|
+    unless self.respond_to?(method)
+      eval %|def #{method}(*args, &block); Kintama.#{method}(*args, &block); end|
+    end
   end
 end
 

data/lib/kintama/assertions.rb

@@ -34,6 +34,10 @@ module Kintama
       assert thing.is_a?(klass), message
     end
 
+    def assert_same(expected, actual, message="Expected #{expected.inspect} (oid=#{expected.object_id}) to be the same as #{actual.inspect} (oid=#{actual.object_id})")
+      assert actual.equal?(expected), message
+    end
+
     def assert_same_elements(expected, object, message = "#{object.inspect} does not contain the same elements as #{expected.inspect}")
       assert Set.new(expected) == Set.new(object), message
     end

data/lib/kintama/context.rb

@@ -1,9 +1,46 @@
 module Kintama
   module Context
-    def setup # noop
+    def setup
+      (setup_blocks + after_setup_blocks).each do |block|
+        instance_eval(&block)
+      end
+    end
+
+    def teardown
+      blocks = teardown_blocks
+      blocks.each do |block|
+        instance_eval(&block)
+      end
     end
 
-    def teardown # noop
+    def setup_blocks
+      context = self.class
+      blocks = context.setup_blocks
+      while(context.superclass.respond_to?(:setup_blocks))
+        context = context.superclass
+        blocks.unshift(*context.setup_blocks)
+      end
+      blocks
+    end
+
+    def after_setup_blocks
+      context = self.class
+      blocks = context.after_setup_blocks
+      while(context.superclass.respond_to?(:after_setup_blocks))
+        context = context.superclass
+        blocks.unshift(*context.after_setup_blocks)
+      end
+      blocks
+    end
+
+    def teardown_blocks
+      context = self.class
+      blocks = context.teardown_blocks
+      while(context.superclass.respond_to?(:teardown_blocks))
+        context = context.superclass
+        blocks.push(*context.teardown_blocks)
+      end
+      blocks
     end
 
     def self.included(base)
@@ -21,7 +58,7 @@ module Kintama
         end
       end
 
-      def find_definition_1_9(&block)
+      def find_definition_yarv(&block)
         block.source_location if block
       end
 
@@ -35,8 +72,8 @@ module Kintama
       def find_definition(&block)
         if defined? RUBY_ENGINE
           case RUBY_ENGINE
-          when "ruby"
-            RUBY_VERSION =~ /^1.9/ ? find_definition_1_9(&block) : find_definition_1_8
+          when "ruby", "jruby"
+            Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('1.9') ? find_definition_yarv(&block) : find_definition_1_8
           when "rbx"
             find_definition_rbx(&block)
           end
@@ -67,6 +104,10 @@ module Kintama
         @setup_blocks ||= []
       end
 
+      def after_setup_blocks
+        @after_setup_blocks ||= []
+      end
+
       def teardown_blocks
         @teardown_blocks ||= []
       end
@@ -75,26 +116,17 @@ module Kintama
       # It will also be run for any subcontexts, before their own setup blocks
       def setup(&block)
         self.setup_blocks << block
+      end
 
-        # redefine setup for the current set of blocks
-        blocks = self.setup_blocks
-        define_method(:setup) do
-          super()
-          blocks.each { |b| instance_eval(&b) }
-        end
+      def after_setup(&block)
+        self.after_setup_blocks << block
       end
+      alias_method :action, :after_setup
 
       # Define the teardown for this context.
       # It will also be run for any subcontexts, after their own teardown blocks
       def teardown(&block)
         self.teardown_blocks << block
-
-        # redefine teardown for the current set of blocks
-        blocks = self.teardown_blocks
-        define_method(:teardown) do
-          blocks.each { |b| instance_eval(&b) }
-          super()
-        end
       end
 
       def on_start_blocks
@@ -115,11 +147,16 @@ module Kintama
       end
       alias_method :after_all, :on_finish
 
+      def let(name, &block)
+        define_method(name) do
+          memo = "@__#{name}"
+          instance_variable_get(memo) || instance_variable_set(memo, instance_eval(&block))
+        end
+      end
+
       # Defines the subject of any matcher-based tests.
       def subject(&block)
-        define_method(:subject) do
-          @__subject ||= yield
-        end
+        let("subject", &block)
       end
 
       # Define a test to run in this context.
@@ -199,28 +236,6 @@ module Kintama
         subcontexts.find { |s| s.name == name } || tests.find { |t| t.name == name }
       end
 
-      def method_missing(name, *args, &block)
-        if self[de_methodize(name)]
-          self[de_methodize(name)]
-        else
-          begin
-            super
-          rescue NameError, NoMethodError => e
-            if parent
-              parent.send(name, *args, &block)
-            else
-              raise e
-            end
-          end
-        end
-      end
-
-      def respond_to?(name)
-        self[name] ||
-        super ||
-        (parent ? parent.respond_to?(name) : false)
-      end
-
       # Runs all tests in this context and any subcontexts.
       # Returns true if all tests passed; otherwise false
       def run(reporter=nil)
@@ -257,10 +272,6 @@ module Kintama
 
       private
 
-      def de_methodize(name)
-        name.to_s.gsub("_", " ")
-      end
-
       def ran_tests
         @ran_tests || []
       end

data/lib/kintama/mocha.rb

@@ -1,3 +1,4 @@
+require 'kintama'
 require 'mocha/api'
 
 Kintama.include Mocha::API
@@ -10,3 +11,15 @@ Kintama.teardown do
     mocha_teardown
   end
 end
+
+module Kintama::Mocha
+  module Expect
+    def expect(name, &block)
+      context do
+        setup(&block)
+        test("expect " + name) {}
+      end
+    end
+  end
+end
+Kintama.extend(Kintama::Mocha::Expect)

data/lib/kintama/no_conflict.rb

@@ -0,0 +1,2 @@
+ENV["KINTAMA_NO_CONFLICT"] = "true"
+require "kintama"

data/lib/kintama/reporter.rb

@@ -17,9 +17,9 @@ module Kintama
     end
 
     class Base
-      attr_reader :runner
+      attr_reader :runner, :test_count
 
-      def initialize
+      def initialize(*args)
         @test_count = 0
       end
 
@@ -157,4 +157,4 @@ module Kintama
     end
 
   end
-end
+end

data/test/{automatic_running_test.rb → integration/automatic_running_test.rb}

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class AutomaticRunningTest < Test::Unit::TestCase
 
-  def test_should_be_able_to_run_tests_automatically_when_file_is_loaded
+  def test_should_be_able_to_run_kintama_tests_automatically_when_file_is_loaded
     assert_passes write_test %{
       context "given a thing" do
         should "work" do
@@ -27,7 +27,7 @@ class AutomaticRunningTest < Test::Unit::TestCase
     "/tmp/kintama_tmp_test.rb"
   end
 
-  def run_test(path)
+  def run_kintama_test(path)
     prev = ENV["KINTAMA_EXPLICITLY_DONT_RUN"]
     ENV["KINTAMA_EXPLICITLY_DONT_RUN"] = nil
     output = `ruby #{path}`
@@ -36,10 +36,10 @@ class AutomaticRunningTest < Test::Unit::TestCase
   end
 
   def assert_passes(path)
-    assert_equal 0, run_test(path).exitstatus
+    assert_equal 0, run_kintama_test(path).exitstatus
   end
 
   def assert_fails(path)
-    assert_equal 1, run_test(path).exitstatus
+    assert_equal 1, run_kintama_test(path).exitstatus
   end
-end
+end

data/test/{line_based_running_test.rb → integration/line_based_running_test.rb}

@@ -11,11 +11,11 @@ class LineBasedRunningTest < Test::Unit::TestCase
           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 /^#{passing("should run this test")}\n\n1 tests/, run_kintama_test(test_file, "--line 3")
+    assert_match /^1 tests, 0 failures/, run_kintama_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")
+    assert_match /^#{failing("should not run this test")}\n\n1 tests/, run_kintama_test(test_file, "--line 6")
+    assert_match /^1 tests, 1 failures/, run_kintama_test(test_file, "--line 6")
   end
 
   def test_should_be_able_to_run_the_test_by_giving_the_line_number_within_the_test_definition
@@ -28,8 +28,8 @@ class LineBasedRunningTest < Test::Unit::TestCase
           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")
+    assert_match /^#{passing("should run this test")}\n\n1 tests/, run_kintama_test(test_file, "--line 4")
+    assert_match /^#{failing("should not run this test")}\n\n1 tests/, run_kintama_test(test_file, "--line 7")
   end
 
   def test_should_be_able_to_run_all_tests_within_a_context_when_line_falls_on_a_context
@@ -45,7 +45,7 @@ class LineBasedRunningTest < Test::Unit::TestCase
           end
         end
       end}
-    assert_match /#{passing("should run this test")}\n#{passing("should run this test too")}\n\n2 tests/, run_test(test_file, "--line 6")
+    assert_match /#{passing("should run this test")}\n#{passing("should run this test too")}\n\n2 tests/, run_kintama_test(test_file, "--line 6")
   end
 
   def test_should_be_able_to_run_a_test_defined_in_a_second_top_level_context
@@ -59,7 +59,7 @@ class LineBasedRunningTest < Test::Unit::TestCase
         should "run this test" do
         end
       end}
-    assert_match /#{passing("should run this test")}\n\n1 tests/, run_test(test_file, "--line 8")
+    assert_match /#{passing("should run this test")}\n\n1 tests/, run_kintama_test(test_file, "--line 8")
   end
 
   def test_should_print_out_the_full_nested_test_name
@@ -70,7 +70,7 @@ class LineBasedRunningTest < Test::Unit::TestCase
           end
         end
       end}
-    assert_match /given a test\n  that is nested deeply\n/, run_test(test_file, "--line 5")
+    assert_match /given a test\n  that is nested deeply\n/, run_kintama_test(test_file, "--line 5")
   end
 
   def test_should_not_show_pending_tests_in_the_same_context_as_pending_when_not_targeted
@@ -80,7 +80,7 @@ class LineBasedRunningTest < Test::Unit::TestCase
         end
         should "ignore the pending test"
       end}
-    assert_no_match /1 pending/, run_test(test_file, "--line 3")
+    assert_no_match /1 pending/, run_kintama_test(test_file, "--line 3")
   end
 
   def test_should_be_able_to_target_a_top_level_context
@@ -94,7 +94,7 @@ class LineBasedRunningTest < Test::Unit::TestCase
         should "run this too" do
         end
       end}
-    assert_match /2 tests/, run_test(test_file, "--line 2")
+    assert_match /2 tests/, run_kintama_test(test_file, "--line 2")
   end
 
   def test_should_report_if_nothing_runnable_can_be_found_for_that_line
@@ -103,7 +103,7 @@ class LineBasedRunningTest < Test::Unit::TestCase
         should "not run this" do
         end
       end}
-    assert_match /Nothing runnable found on line 1/, run_test(test_file, "--line 1")
+    assert_match /Nothing runnable found on line 1/, run_kintama_test(test_file, "--line 1")
   end
 
   private
@@ -115,7 +115,7 @@ class LineBasedRunningTest < Test::Unit::TestCase
     end
   end
 
-  def run_test(test_content, options)
+  def run_kintama_test(test_content, options)
     path = "/tmp/kintama_tmp_test.rb"
     write_test(test_content.strip, path)
     prev = ENV["KINTAMA_EXPLICITLY_DONT_RUN"]

data/test/reporters/base_reporter_test.rb

@@ -1,10 +1,7 @@
 require 'test_helper'
 
-class BaseReporterTest < Test::Unit::TestCase
-
-  def setup
-    @reporter = Kintama::Reporter::Base.new
-  end
+class BaseReporterTest < KintamaIntegrationTest
+  report_with Kintama::Reporter::Base
 
   def test_assert_output_works
     assert_output("yes\n") do
@@ -13,145 +10,78 @@ class BaseReporterTest < Test::Unit::TestCase
   end
 
   def test_should_print_summary_when_a_test_passes
-    c = context "given something" do
+    context "given something" do
       should "pass" do
         assert true
       end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^1 tests, 0 failures/, @reporter.test_summary
+    end.
+    should_output("1 tests, 0 failures")
   end
 
   def test_should_print_out_summary_when_multiple_tests_pass
-    c = context "given something" do
+    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(@reporter) }
-    assert_match /^2 tests, 0 failures/, @reporter.test_summary
+    end.
+    should_output("2 tests, 0 failures")
   end
 
   def test_should_print_out_summary_when_a_pending_test_exists
-    c = context "given something" do
+    context "given something" do
       should "pass" do
         assert true
       end
       should "not be implemented yet"
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^2 tests, 0 failures, 1 pending/, @reporter.test_summary
+    end.
+    should_output("2 tests, 0 failures, 1 pending")
   end
 
   def test_should_print_out_failure_details_if_tests_fail
-    c = context "given something" do
+    context "given something" do
       should "fail" do
         flunk
       end
       should "pass" do
         assert true
       end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^1\) given something should fail:\n  flunked\./, @reporter.failure_messages[0]
+    end.
+    should_output(%{
+      1) given something should fail:
+        flunked
+    })
   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(@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
-    c1 = context "given something" do
+    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(@reporter) }
-    assert_match /^2 tests, 0 failures/, @reporter.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(@reporter)
-    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(@reporter)
-    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(@reporter), "should not have run the context twice"
-    end
+    end.
+    should_output(/^1 tests, 0 failures \(0\.\d+ seconds\)/)
   end
 
   def test_should_print_out_the_names_of_tests_that_fail
-    c = context "given something" do
+    context "given something" do
       should "fail" do
         flunk
       end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /^1\) given something should fail:\n  flunked\./, @reporter.failure_messages[0]
+    end.
+    should_output(%{
+      1) given something should fail:
+        flunked
+    })
   end
 
   def test_should_include_line_in_test_of_error_in_failure_message
-    c = context "given jazz" do
-      should "tapdance" do
+    context "given a test that fails" do
+      should "report line of failing test" do
         $line = __LINE__; flunk
       end
-    end
-    r = runner(c)
-    capture_stdout { r.run(@reporter) }
-    assert_match /#{Regexp.escape(File.expand_path(__FILE__))}:#{$line}/, @reporter.failure_messages.first
+    end.
+    should_output(/#{Regexp.escape(File.expand_path(__FILE__))}:#{$line}/)
   end
-
-  private
-
-  def runner(*args)
-    Kintama::Runner::Default.new.with(*args)
-  end
-
-end
+end