assert 0.6.0 → 0.7.0

data/lib/assert/test.rb

@@ -9,29 +9,38 @@ module Assert
     include Assert::Options
     options do
       default_capture_output false
+      default_halt_on_fail   true
+    end
+
+    def self.halt_on_fail?
+      ENV['halt_on_fail'] == 'true' || self.options.halt_on_fail
     end
 
     # a Test is some code/method to run in the scope of a Context.  After a
     # a test runs, it should have some assertions which are its results.
 
-    attr_reader :name, :code, :context_class
+    attr_reader :name, :code, :context_info
     attr_accessor :results, :output
 
-    def initialize(name, context_class, code = nil, &block)
-      @context_class = context_class
+    def initialize(name, suite_context_info, code = nil, &block)
+      @context_info = suite_context_info
       @name = name_from_context(name)
       @code = (code || block)
       @results = ResultSet.new
       @output = ""
     end
 
+    def context_class
+      self.context_info.klass
+    end
+
     def run(view=nil)
       @results.view = view
-      run_scope = @context_class.new(self)
+      run_scope = self.context_class.new(self)
       capture_output(StringIO.new(@output, "w+")) do
         begin
           # run any assert style 'setup do' setups
-          @context_class.setup(run_scope)
+          self.context_class.setup(run_scope)
           # run any classic test/unit style 'def setup' setups
           if run_scope.respond_to?(:setup)
             run_scope.setup
@@ -43,10 +52,12 @@ module Assert
           elsif run_scope.respond_to?(@code.to_s)
             run_scope.send(@code.to_s)
           end
+        rescue Result::TestFailure => err
+          @results << Result::Fail.new(self, err)
         rescue Result::TestSkipped => err
-          @results << Result::Skip.new(self.name, err)
+          @results << Result::Skip.new(self, err)
         rescue Exception => err
-          @results << Result::Error.new(self.name, err)
+          @results << Result::Error.new(self, err)
         ensure
           begin
             # run any classic test/unit style 'def teardown' teardowns
@@ -54,9 +65,9 @@ module Assert
               run_scope.teardown
             end
             # run any assert style 'teardown do' teardowns
-            @context_class.teardown(run_scope)
+            self.context_class.teardown(run_scope)
           rescue Exception => teardown_err
-            @results << Result::Error.new(self.name, teardown_err)
+            @results << Result::Error.new(self, teardown_err)
           end
         end
       end
@@ -83,7 +94,7 @@ module Assert
     end
 
     def inspect
-      attributes_string = ([ :name, :context_class, :results ].collect do |attr|
+      attributes_string = ([ :name, :context_info, :results ].collect do |attr|
         "@#{attr}=#{self.send(attr).inspect}"
       end).join(" ")
       "#<#{self.class} #{attributes_string}>"
@@ -103,7 +114,7 @@ module Assert
     end
 
     def name_from_context(name)
-      [ @context_class.description,
+      [ self.context_class.description,
         name.gsub(/^test:\s+should/, "should")
       ].compact.reject{|p| p.empty?}.join(" ")
     end

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/test/assertions_test.rb

@@ -28,7 +28,7 @@ module Assert::Assertions
     desc "ignored assertions helpers"
     setup do
       @tests = Assert::Assertions::IGNORED_ASSERTION_HELPERS.collect do |helper|
-        Factory.test("ignored assertion helper #{helper}", @context_class) do
+        Factory.test("ignored assertion helper #{helper}", Factory.context_info(@context_class)) do
           self.send(helper, "doesn't matter")
         end
       end

data/test/context/class_methods_test.rb

@@ -5,11 +5,14 @@ class Assert::Context
   class ClassMethodsTest < Assert::Context
     desc "Assert context class"
     setup do
+      @orig_assert_suite = Assert.suite
+      Assert.options.suite TEST_ASSERT_SUITE
       @test = Factory.test
       @context_class = @test.context_class
     end
     teardown do
-      TEST_ASSERT_SUITE.clear
+      TEST_ASSERT_SUITE.tests.clear
+      Assert.options.suite @orig_assert_suite
     end
     subject{ @context_class }
 
@@ -296,19 +299,21 @@ class Assert::Context
   class TestMethTest < ClassMethodsTest
     desc "test method"
     setup do
+      @test_count_before = Assert.suite.tests.size
+
       @should_desc = "be true"
       @should_block = ::Proc.new{ assert(true) }
       @method_name = "test: #{@should_desc}"
 
       d, b = @should_desc, @should_block
       @context_class = Factory.context_class { test(d, &b) }
-      @context = @context_class.new(Factory.test("something", @context_class))
+      @context = @context_class.new(Factory.test("something", Factory.context_info(@context_class)))
     end
     subject{ @context }
 
     should "define a test method named after the should desc" do
-      assert_respond_to @method_name, subject
-      assert_equal subject.instance_eval(&@should_block), subject.send(@method_name)
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal @should_block, Assert.suite.tests.last.code
     end
 
   end
@@ -318,13 +323,13 @@ class Assert::Context
     setup do
       d = @should_desc
       @context_class = Factory.context_class { test(d) }
-      @context = @context_class.new(Factory.test("something", @context_class))
+      @context = @context_class.new(Factory.test("something", Factory.context_info(@context_class)))
     end
     subject{ @context }
 
     should "define a test method named after the should desc that raises a test skipped" do
       assert_raises(Assert::Result::TestSkipped) do
-        subject.send(@method_name)
+        subject.instance_eval(&Assert.suite.tests.last.code)
       end
     end
 
@@ -337,14 +342,13 @@ class Assert::Context
       @context_class = Factory.context_class do
         test_eventually(d, &b)
       end
-      @context = @context_class.new(Factory.test("something", @context_class))
+      @context = @context_class.new(Factory.test("something", Factory.context_info(@context_class)))
     end
     subject{ @context }
 
     should "define a test method named after the should desc that raises a test skipped" do
-      assert_respond_to @method_name, subject
       assert_raises(Assert::Result::TestSkipped) do
-        subject.send(@method_name)
+        subject.instance_eval(&Assert.suite.tests.last.code)
       end
     end
 
@@ -355,19 +359,21 @@ class Assert::Context
   class ShouldTest < ClassMethodsTest
     desc "'should' method"
     setup do
+      @test_count_before = Assert.suite.tests.size
+
       @should_desc = "be true"
       @should_block = ::Proc.new{ assert(true) }
       @method_name = "test: should #{@should_desc}"
 
       d, b = @should_desc, @should_block
       @context_class = Factory.context_class { should(d, &b) }
-      @context = @context_class.new(Factory.test("something", @context_class))
+      @context = @context_class.new(Factory.test("something", Factory.context_info(@context_class)))
     end
     subject{ @context }
 
     should "define a test method named after the should desc" do
-      assert_respond_to @method_name, subject
-      assert_equal subject.instance_eval(&@should_block), subject.send(@method_name)
+      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal @should_block, Assert.suite.tests.last.code
     end
 
   end
@@ -377,13 +383,13 @@ class Assert::Context
     setup do
       d = @should_desc
       @context_class = Factory.context_class { should(d) }
-      @context = @context_class.new(Factory.test("something", @context_class))
+      @context = @context_class.new(Factory.test("something", Factory.context_info(@context_class)))
     end
     subject{ @context }
 
     should "define a test method named after the should desc that raises a test skipped" do
       assert_raises(Assert::Result::TestSkipped) do
-        subject.send(@method_name)
+        subject.instance_eval(&Assert.suite.tests.last.code)
       end
     end
 
@@ -394,14 +400,13 @@ class Assert::Context
     setup do
       d, b = @should_desc, @should_block
       @context_class = Factory.context_class { should_eventually(d, &b) }
-      @context = @context_class.new(Factory.test("something", @context_class))
+      @context = @context_class.new(Factory.test("something", Factory.context_info(@context_class)))
     end
     subject{ @context }
 
     should "define a test method named after the should desc that raises a test skipped" do
-      assert_respond_to @method_name, subject
       assert_raises(Assert::Result::TestSkipped) do
-        subject.send(@method_name)
+        subject.instance_eval(&Assert.suite.tests.last.code)
       end
     end
 

data/test/context_test.rb

@@ -10,7 +10,7 @@ class Assert::Context
       @context = @context_class.new(@test)
     end
     teardown do
-      TEST_ASSERT_SUITE.clear
+      TEST_ASSERT_SUITE.tests.clear
     end
     subject{ @context }
 
@@ -18,6 +18,11 @@ class Assert::Context
     should have_instance_methods :skip, :pass, :fail, :flunk, :ignore
     should have_instance_methods :subject
 
+    def test_should_collect_context_info
+      assert_match /test\/context_test.rb$/, @__running_test__.context_info.file
+      assert_equal self.class, @__running_test__.context_info.klass
+    end
+
   end
 
 
@@ -86,7 +91,7 @@ class Assert::Context
 
 
 
-  class FailTest < BasicTest
+  class FailTests < BasicTest
     desc "fail method"
     setup do
       @result = @context.fail
@@ -98,11 +103,28 @@ class Assert::Context
     end
     should "set the calling backtrace on the result" do
       assert_kind_of Array, subject.backtrace
-      assert_match /assert\/test\/context_test\.rb/, subject.trace
+      assert_equal Factory.context_info_called_from, subject.trace
+    end
+  end
+
+  class FlunkTest < BasicTest
+    desc "flunk method"
+    setup do
+      @flunk_msg = "It flunked."
+      @result = @context.flunk(@flunk_msg)
+    end
+    subject{ @result }
+
+    should "create a fail result" do
+      assert_kind_of Assert::Result::Fail, subject
+    end
+    should "set the message passed to it on the result" do
+      assert_equal @flunk_msg, subject.message
     end
+
   end
 
-  class StringMessageTest < FailTest
+  class StringMessageTests < FailTests
     desc "with a string message"
     setup do
       @fail_msg = "Didn't work"
@@ -115,7 +137,7 @@ class Assert::Context
 
   end
 
-  class ProcMessageTest < FailTest
+  class ProcMessageTests < FailTests
     desc "with a proc message"
     setup do
       @fail_msg = ::Proc.new{ "Still didn't work" }
@@ -130,25 +152,55 @@ class Assert::Context
 
 
 
-  class FlunkTest < BasicTest
-    desc "flunk method"
+
+
+
+  class SaveRestoreHaltOnFailTests < BasicTest
+    desc "when not halting on fails"
     setup do
-      @flunk_msg = "It flunked."
-      @result = @context.flunk(@flunk_msg)
+      @prev_halt_option = Assert::Test.options.halt_on_fail
+      @prev_halt_envvar = ENV['halt_on_fail']
+    end
+    teardown do
+      Assert::Test.options.halt_on_fail @prev_halt_option
+      ENV['halt_on_fail'] = @prev_halt_envvar
+    end
+  end
+
+  class HaltOnFailTests < SaveRestoreHaltOnFailTests
+    setup do
+      ENV['halt_on_fail'] = 'true'
+      Assert::Test.options.halt_on_fail true
+    end
+  end
+
+  class HaltFailTests < HaltOnFailTests
+    desc "fail method"
+    setup do
+      @fail_msg = "something failed"
+      begin
+        @context.fail @fail_msg
+      rescue Exception => @exception
+      end
+      @result = Assert::Result::Fail.new(Factory.test("something"), @exception)
     end
     subject{ @result }
 
-    should "create a fail result" do
-      assert_kind_of Assert::Result::Fail, subject
+    should "raise a test failure exception when called" do
+      assert_kind_of Assert::Result::TestFailure, @exception
+    end
+    should "raise the exception with the message passed to it" do
+      assert_equal @fail_msg, @exception.message
     end
     should "set the message passed to it on the result" do
-      assert_equal @flunk_msg, subject.message
+      assert_equal @fail_msg, subject.message
     end
 
   end
 
 
 
+
   class AssertTest < BasicTest
     desc "assert method"
     setup do

data/test/helper.rb

@@ -15,14 +15,33 @@ TEST_ASSERT_SUITE = Assert::Suite.new
 # factory by default. This will ensure any contexts you define in your tests will not be shoved
 # onto the the suite running the tests.
 class TestContext < Assert::Context
-  def self.inherited(klass)
-    TEST_ASSERT_SUITE << klass
+  def self.method_added(meth)
+    if meth.to_s =~ Assert::Suite::TEST_METHOD_REGEX
+      ci = Assert::Suite::ContextInfo.new(self, Assert.suite.current_caller_info)
+      TEST_ASSERT_SUITE.tests << Assert::Test.new(meth.to_s, ci, meth)
+    end
+  end
+end
+
+# force tests to run without halting on fail (needed for tests to run)
+# anywhere we test halt on fail behavior, we take care of it in the specific context
+class Assert::Context
+  def setup
+    ENV['halt_on_fail'] = 'false'
+    Assert::Test.options.halt_on_fail false
   end
 end
 
 module Factory
   class << self
 
+    def context_info_called_from
+      "/path/to_file.rb:1234"
+    end
+
+    def context_info(context_class)
+      Assert::Suite::ContextInfo.new(context_class, context_info_called_from)
+    end
     # Generates an anonymous class inherited from whatever you pass or TextContext by default. This
     # provides a common interface for all context classes to be generated in the tests.
     def context_class(inherit_from = nil, &block)
@@ -40,15 +59,15 @@ module Factory
     # if you need a no-op test.
     def test(*args, &block)
       name = (args[0] || "a test").to_s
-      context_class = args[1] || self.context_class
+      context_info = args[1] || self.context_info(self.context_class)
       test_block = (block || args[2] || ::Proc.new{})
 
-      Assert::Test.new(name, context_class, &test_block)
+      Assert::Test.new(name, context_info, &test_block)
     end
 
     # Common interface for generating a new skip result
     def skip_result(name, exception)
-      Assert::Result::Skip.new(name, exception)
+      Assert::Result::Skip.new(Factory.test(name), exception)
     end
 
   end

data/test/rake_tasks/irb_test.rb

@@ -0,0 +1,45 @@
+require 'assert'
+
+require 'assert/rake_tasks/irb'
+
+module Assert::RakeTasks
+
+  class IrbTests < Assert::Context
+    desc "the irb task handler"
+    setup do
+      @root_path = :test
+      @handler = Assert::RakeTasks::Irb.new(@root_path)
+    end
+    subject { @handler }
+
+    should have_class_method :task_name, :file_name
+    should have_instance_methods :file_path, :helper_exists?, :description, :cmd
+
+    should "know its rake task name" do
+      assert_equal :irb, subject.class.task_name
+    end
+
+    should "know the irb helper file name" do
+      assert_equal "irb.rb", subject.class.file_name
+    end
+
+    should "know the irb helper file path" do
+      assert_equal File.join(@root_path.to_s, subject.class.file_name), subject.file_path
+    end
+
+    should "know if the irb helper exists" do
+      # this is true b/c assert has a test/helper.rb file defined
+      assert_equal true, subject.helper_exists?
+    end
+
+    should "know the description of the irb task" do
+      assert_equal "Open irb preloaded with #{subject.file_path}", subject.description
+    end
+
+    should "know the shell command to run the irb task" do
+      assert_equal "irb -rubygems -r ./#{subject.file_path}", subject.cmd
+    end
+
+  end
+
+end