assert 2.3.1 → 2.3.2

data/lib/assert/assertions.rb

@@ -1,154 +1,162 @@
 module Assert
   module Assertions
 
-    def assert_block(desc=nil)
-      msg ||= "Expected block to return a true value."
-      assert(yield, desc, msg)
+    def assert_block(desc = nil)
+      assert(yield, desc){ "Expected block to return a true value." }
     end
 
-    def assert_not_block(desc=nil)
-      msg ||= "Expected block to return a false value."
-      assert(!yield, desc, msg)
+    def assert_not_block(desc = nil)
+      assert(!yield, desc){ "Expected block to return a false value." }
     end
     alias_method :refute_block, :assert_not_block
 
-    def assert_empty(collection, desc=nil)
-      msg = "Expected #{collection.inspect} to be empty."
-      assert(collection.empty?, desc, msg)
+    def assert_empty(collection, desc = nil)
+      assert(collection.empty?, desc) do
+        "Expected #{collection.inspect} to be empty."
+      end
     end
 
-    def assert_not_empty(collection, desc=nil)
-      msg = "Expected #{collection.inspect} to not be empty."
-      assert(!collection.empty?, desc, msg)
+    def assert_not_empty(collection, desc = nil)
+      assert(!collection.empty?, desc) do
+        "Expected #{collection.inspect} to not be empty."
+      end
     end
     alias_method :refute_empty, :assert_not_empty
 
-    def assert_equal(expected, actual, desc=nil)
-      msg = "Expected #{expected.inspect}, not #{actual.inspect}."
-      assert(actual == expected, desc, msg)
+    def assert_equal(expected, actual, desc = nil)
+      assert(actual == expected, desc) do
+        "Expected #{expected.inspect}, not #{actual.inspect}."
+      end
     end
 
-    def assert_not_equal(expected, actual, desc=nil)
-      msg = "#{actual.inspect} not expected to equal #{expected.inspect}."
-      assert(actual != expected, desc, msg)
+    def assert_not_equal(expected, actual, desc = nil)
+      assert(actual != expected, desc) do
+        "#{actual.inspect} not expected to equal #{expected.inspect}."
+      end
     end
     alias_method :refute_equal, :assert_not_equal
 
-    def assert_file_exists(file_path, desc=nil)
-      msg = "Expected #{file_path.inspect} to exist."
-      assert(File.exists?(File.expand_path(file_path)), desc, msg)
+    def assert_file_exists(file_path, desc = nil)
+      assert(File.exists?(File.expand_path(file_path)), desc) do
+        "Expected #{file_path.inspect} to exist."
+      end
     end
 
-    def assert_not_file_exists(file_path, desc=nil)
-      msg = "Expected #{file_path.inspect} to not exist."
-      assert(!File.exists?(File.expand_path(file_path)), desc, msg)
+    def assert_not_file_exists(file_path, desc = nil)
+      assert(!File.exists?(File.expand_path(file_path)), desc) do
+        "Expected #{file_path.inspect} to not exist."
+      end
     end
     alias_method :refute_file_exists, :assert_not_file_exists
 
-    def assert_includes(object, collection, desc=nil)
-      msg = "Expected #{collection.inspect} to include #{object.inspect}."
-      assert(collection.include?(object), desc, msg)
+    def assert_includes(object, collection, desc = nil)
+      assert(collection.include?(object), desc) do
+        "Expected #{collection.inspect} to include #{object.inspect}."
+      end
     end
     alias_method :assert_included, :assert_includes
 
-    def assert_not_includes(object, collection, desc=nil)
-      msg = "Expected #{collection.inspect} to not include #{object.inspect}."
-      assert(!collection.include?(object), desc, msg)
+    def assert_not_includes(object, collection, desc = nil)
+      assert(!collection.include?(object), desc) do
+        "Expected #{collection.inspect} to not include #{object.inspect}."
+      end
     end
     alias_method :assert_not_included, :assert_not_includes
     alias_method :refute_includes, :assert_not_includes
     alias_method :refute_included, :assert_not_includes
 
-    def assert_instance_of(klass, instance, desc=nil)
-      msg = "Expected #{instance.inspect} (#{instance.class}) to"\
-            " be an instance of #{klass}."
-      assert(instance.instance_of?(klass), desc, msg)
+    def assert_instance_of(klass, instance, desc = nil)
+      assert(instance.instance_of?(klass), desc) do
+        "Expected #{instance.inspect} (#{instance.class}) to be an instance of #{klass}."
+      end
     end
 
-    def assert_not_instance_of(klass, instance, desc=nil)
-      msg = "#{instance.inspect} not expected to be an instance of #{klass}."
-      assert(!instance.instance_of?(klass), desc, msg)
+    def assert_not_instance_of(klass, instance, desc = nil)
+      assert(!instance.instance_of?(klass), desc) do
+        "#{instance.inspect} (#{instance.class}) not expected to be an instance of #{klass}."
+      end
     end
     alias_method :refute_instance_of, :assert_not_instance_of
 
     def assert_kind_of(klass, instance, desc=nil)
-      msg = "Expected #{instance.inspect} (#{instance.class}) to"\
-            " be a kind of #{klass}."
-      assert(instance.kind_of?(klass), desc, msg)
+      assert(instance.kind_of?(klass), desc) do
+        "Expected #{instance.inspect} (#{instance.class}) to be a kind of #{klass}."
+      end
     end
 
     def assert_not_kind_of(klass, instance, desc=nil)
-      msg = "#{instance.inspect} not expected to be a kind of #{klass}."
-      assert(!instance.kind_of?(klass), desc, msg)
+      assert(!instance.kind_of?(klass), desc) do
+        "#{instance.inspect} not expected to be a kind of #{klass}."
+      end
     end
     alias_method :refute_kind_of, :assert_not_kind_of
 
     def assert_match(expected, actual, desc=nil)
-      msg = "Expected #{actual.inspect} to match #{expected.inspect}."
-      expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
-      assert(actual =~ expected, desc, msg)
+      exp = String === expected && String === actual ? /#{Regexp.escape(expected)}/ : expected
+      assert(actual =~ exp, desc) do
+        "Expected #{actual.inspect} to match #{expected.inspect}."
+      end
     end
 
     def assert_not_match(expected, actual, desc=nil)
-      msg = "#{actual.inspect} not expected to match #{expected.inspect}."
-      expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
-      assert(actual !~ expected, desc, msg)
+      exp = String === expected && String === actual ? /#{Regexp.escape(expected)}/ : expected
+      assert(actual !~ exp, desc) do
+        "#{actual.inspect} not expected to match #{expected.inspect}."
+      end
     end
     alias_method :refute_match, :assert_not_match
     alias_method :assert_no_match, :assert_not_match
 
     def assert_nil(object, desc=nil)
-      msg = "Expected nil, not #{object.inspect}."
-      assert(object.nil?, desc, msg)
+      assert(object.nil?, desc){ "Expected nil, not #{object.inspect}." }
     end
 
     def assert_not_nil(object, desc=nil)
-      msg = "Expected #{object.inspect} to not be nil."
-      assert(!object.nil?, desc, msg)
+      assert(!object.nil?, desc){ "Expected #{object.inspect} to not be nil." }
     end
     alias_method :refute_nil, :assert_not_nil
 
     def assert_raises(*exceptions, &block)
       desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
       err = RaisedException.new(exceptions, &block)
-      assert(err.raised?, desc, err.msg)
+      assert(err.raised?, desc){ err.msg }
     end
     alias_method :assert_raise, :assert_raises
 
     def assert_nothing_raised(*exceptions, &block)
       desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
       err = NoRaisedException.new(exceptions, &block)
-      assert(!err.raised?, desc, err.msg)
+      assert(!err.raised?, desc){ err.msg }
     end
     alias_method :assert_not_raises, :assert_nothing_raised
     alias_method :assert_not_raise, :assert_nothing_raised
 
     def assert_respond_to(method, object, desc=nil)
-      msg = "Expected #{object.inspect} (#{object.class}) to"\
-            " respond to `#{method}`."
-      assert(object.respond_to?(method), desc, msg)
+      assert(object.respond_to?(method), desc) do
+        "Expected #{object.inspect} (#{object.class}) to respond to `#{method}`."
+      end
     end
     alias_method :assert_responds_to, :assert_respond_to
 
     def assert_not_respond_to(method, object, desc=nil)
-      msg = "#{object.inspect} (#{object.class}) not expected to"\
-            " respond to `#{method}`."
-      assert(!object.respond_to?(method), desc, msg)
+      assert(!object.respond_to?(method), desc) do
+        "#{object.inspect} (#{object.class}) not expected to respond to `#{method}`."
+      end
     end
     alias_method :assert_not_responds_to, :assert_not_respond_to
     alias_method :refute_respond_to, :assert_not_respond_to
     alias_method :refute_responds_to, :assert_not_respond_to
 
     def assert_same(expected, actual, desc=nil)
-      msg = "Expected #{actual} (#{actual.object_id}) to"\
-            " be the same as #{expected} (#{expected.object_id})."
-      assert(actual.equal?(expected), desc, msg)
+      assert(actual.equal?(expected), desc) do
+        "Expected #{actual} (#{actual.object_id}) to be the same as #{expected} (#{expected.object_id})."
+      end
     end
 
     def assert_not_same(expected, actual, desc=nil)
-      msg = "#{actual} (#{actual.object_id}) not expected to"\
-            " be the same as #{expected} (#{expected.object_id})."
-      assert(!actual.equal?(expected), desc, msg)
+      assert(!actual.equal?(expected), desc) do
+        "#{actual} (#{actual.object_id}) not expected to be the same as #{expected} (#{expected.object_id})."
+      end
     end
     alias_method :refute_same, :assert_not_same
 

data/lib/assert/context.rb

@@ -174,17 +174,19 @@ module Assert
     # check if the assertion is a truthy value, if so create a new pass result, otherwise
     # create a new fail result with the desc and what failed msg.
     # all other assertion helpers use this one in the end
-    def assert(assertion, fail_desc=nil, what_failed_msg=nil)
-      what_failed_msg ||= "Failed assert: assertion was <#{assertion.inspect}>."
-      msg = fail_message(fail_desc) { what_failed_msg }
-      assertion ? pass : fail(msg)
+    def assert(assertion, fail_desc = nil)
+      if assertion
+        pass
+      else
+        what_failed_msg = block_given? ? yield : "Failed assert: assertion was <#{assertion.inspect}>."
+        fail(fail_message(fail_desc, what_failed_msg))
+      end
     end
 
     # the opposite of assert, check if the assertion is a false value, if so create a new pass
     # result, otherwise create a new fail result with the desc and it's what failed msg
-    def assert_not(assertion, fail_desc=nil)
-      what_failed_msg = "Failed assert_not: assertion was <#{assertion.inspect}>."
-      assert(!assertion, fail_desc, what_failed_msg)
+    def assert_not(assertion, fail_desc = nil)
+      assert(!assertion, fail_desc){ "Failed assert_not: assertion was <#{assertion.inspect}>." }
     end
     alias_method :refute, :assert_not
 
@@ -206,13 +208,12 @@ module Assert
 
     # adds a Fail result to the end of the test's results
     # break test execution if Assert.config.halt_on_fail
-    def fail(fail_msg=nil)
-      message = (fail_message(fail_msg) { }).call
+    def fail(message = nil)
       if Assert.config.halt_on_fail
-        raise Result::TestFailure, message
+        raise Result::TestFailure, message || ''
       else
         capture_result do |test, backtrace|
-          Assert::Result::Fail.new(test, message, backtrace)
+          Assert::Result::Fail.new(test, message || '', backtrace)
         end
       end
     end
@@ -220,7 +221,7 @@ module Assert
 
     # adds a Skip result to the end of the test's results and breaks test execution
     def skip(skip_msg=nil)
-      raise(Result::TestSkipped, skip_msg || "")
+      raise(Result::TestSkipped, skip_msg || '')
     end
 
     # alter the backtraces of fail results generated in the given block
@@ -250,10 +251,8 @@ module Assert
     protected
 
     # Returns a Proc that will output a custom message along with the default fail message.
-    def fail_message(fail_desc=nil, &what_failed)
-      fail_desc.kind_of?(::Proc) ? fail_desc : Proc.new do
-        [ fail_desc, what_failed.call ].compact.join("\n")
-      end
+    def fail_message(fail_desc = nil, what_failed_msg = nil)
+      [ fail_desc, what_failed_msg ].compact.join("\n")
     end
 
     private

data/lib/assert/suite.rb

@@ -77,7 +77,7 @@ module Assert
       if block_given?
         self.setups << block
       else
-        self.setups.each{|setup| setup.call}
+        self.setups.each{ |setup| setup.call }
       end
     end
     alias_method :startup, :setup
@@ -86,7 +86,7 @@ module Assert
       if block_given?
         self.teardowns << block
       else
-        self.teardowns.reverse.each{|teardown| teardown.call}
+        self.teardowns.reverse.each{ |teardown| teardown.call }
       end
     end
     alias_method :shutdown, :teardown

data/lib/assert/test.rb

@@ -35,11 +35,19 @@ module Assert
         @results << Result::Fail.new(self, err)
       rescue Result::TestSkipped => err
         @results << Result::Skip.new(self, err)
+      rescue SignalException => err
+        raise(err)
       rescue Exception => err
         @results << Result::Error.new(self, err)
       ensure
         begin
           run_test_teardown(run_scope)
+        rescue Result::TestFailure => err
+          @results << Result::Fail.new(self, err)
+        rescue Result::TestSkipped => err
+          @results << Result::Skip.new(self, err)
+        rescue SignalException => err
+          raise(err)
         rescue Exception => teardown_err
           @results << Result::Error.new(self, teardown_err)
         end

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.3.1"
+  VERSION = "2.3.2"
 end

data/test/unit/assertions/assert_instance_of_tests.rb

@@ -50,7 +50,7 @@ module Assert::Assertions
     end
 
     should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[2]}\n#{@args[1].inspect} not expected to"\
+      exp = "#{@args[2]}\n#{@args[1].inspect} (#{@args[1].class}) not expected to"\
             " be an instance of #{@args[0]}."
       assert_equal exp, subject.fail_results.first.message
     end

data/test/unit/context_tests.rb

@@ -108,12 +108,6 @@ class Assert::Context
       assert_equal fail_msg, result.message
     end
 
-    should "set any given result message evaluated from a proc" do
-      fail_msg = ::Proc.new{ "Still didn't work" }
-      result = @context.fail(fail_msg)
-      assert_equal fail_msg.call, result.message
-    end
-
   end
 
   class HaltOnFailTests < FailTests
@@ -151,13 +145,13 @@ class Assert::Context
     end
 
     should "return a pass result given a `true` assertion" do
-      result = subject.assert(true, @fail_desc, @what_failed)
+      result = subject.assert(true, @fail_desc){ @what_failed }
       assert_kind_of Assert::Result::Pass, result
       assert_nil result.message
     end
 
     should "return a fail result given a `false` assertion" do
-      result = subject.assert(false, @fail_desc, @what_failed)
+      result = subject.assert(false, @fail_desc){ @what_failed }
       assert_kind_of Assert::Result::Fail, result
       assert_equal [@fail_desc, @what_failed].join("\n"), result.message
     end

data/test/unit/test_tests.rb

@@ -7,7 +7,7 @@ class Assert::Test
     desc "a test obj"
     setup do
       @test_code = lambda{ assert(true) }
-      @context_class = Factory.context_class { desc "context class" }
+      @context_class = Factory.context_class{ desc "context class" }
       @context_info  = Factory.context_info(@context_class)
       @test = Factory.test("should do something amazing", @context_info, @test_code)
     end
@@ -51,9 +51,16 @@ class Assert::Test
         ignore("something")
         assert(true)
         assert(false)
-        ignore("something else")
-        assert(34)
-        assert(nil)
+      end
+      @test.context_class.setup do
+        ignore("something")
+        assert(true)
+        assert(false)
+      end
+      @test.context_class.teardown do
+        ignore("something")
+        assert(true)
+        assert(false)
       end
       @test.run
     end
@@ -61,7 +68,7 @@ class Assert::Test
 
     should "know its pass results" do
       assert_kind_of Array, subject.pass_results
-      assert_equal 2, subject.pass_results.size
+      assert_equal 3, subject.pass_results.size
       subject.pass_results.each do |result|
         assert_kind_of Assert::Result::Pass, result
       end
@@ -70,7 +77,7 @@ class Assert::Test
 
     should "know its fail results" do
       assert_kind_of Array, subject.fail_results
-      assert_equal 2, subject.fail_results.size
+      assert_equal 3, subject.fail_results.size
       subject.fail_results.each do |result|
         assert_kind_of Assert::Result::Fail, result
       end
@@ -79,7 +86,7 @@ class Assert::Test
 
     should "know its ignore results" do
       assert_kind_of Array, subject.ignore_results
-      assert_equal 2, subject.ignore_results.size
+      assert_equal 3, subject.ignore_results.size
       subject.ignore_results.each do |result|
         assert_kind_of Assert::Result::Ignore, result
       end
@@ -87,25 +94,48 @@ class Assert::Test
     end
 
     should "know the total number of results" do
-      assert_equal(6, subject.result_count)
+      assert_equal(9, subject.result_count)
     end
 
   end
 
   class SkipHandlingTests < BasicTests
     setup do
-      @test = Factory.test("skip test", @context_info) { skip }
+      @test = Factory.test("skip test", @context_info){ skip }
       @test.run
     end
     subject{ @test }
 
-    should "know its skip results" do
-      assert_kind_of Array, subject.skip_results
-      assert_equal 1, subject.skip_results.size
-      subject.skip_results.each do |result|
-        assert_kind_of Assert::Result::Skip, result
+    should "capture skip results" do
+      assert_skipped(subject)
+    end
+
+    should "capture skips in the context setup" do
+      test = Factory.test("setup skip test", @context_info){ }
+      test.context_class.setup{ skip }
+      test.run
+
+      assert_skipped(test)
+    end
+
+    should "capture skips in the context teardown" do
+      test = Factory.test("teardown skip test", @context_info){ }
+      test.context_class.teardown{ skip }
+      test.run
+
+      assert_skipped(test)
+    end
+
+    private
+
+    def assert_skipped(test)
+      with_backtrace(caller) do
+        assert_equal 1, test.skip_results.size, 'too many/few skip results'
+        test.skip_results.each do |result|
+          assert_kind_of Assert::Result::Skip, result, 'result is not a skip result'
+        end
+        assert_equal test.skip_results.size, test.result_count(:skip), 'skip result not counted'
       end
-      assert_equal subject.skip_results.size, subject.result_count(:skip)
     end
 
   end
@@ -119,13 +149,64 @@ class Assert::Test
     end
     subject{ @test }
 
-    should "know its error results" do
-      assert_kind_of Array, subject.error_results
-      assert_equal 1, subject.error_results.size
-      subject.error_results.each do |result|
-        assert_kind_of Assert::Result::Error, result
+    should "capture error results" do
+      assert_errored(subject)
+    end
+
+    should "capture errors in the context setup" do
+      test = Factory.test("setup error test", @context_info){ }
+      test.context_class.setup{ raise 'an error' }
+      test.run
+
+      assert_errored(test)
+    end
+
+    should "capture errors in the context teardown" do
+      test = Factory.test("teardown error test", @context_info){ }
+      test.context_class.teardown{ raise 'an error' }
+      test.run
+
+      assert_errored(test)
+    end
+
+    private
+
+    def assert_errored(test)
+      with_backtrace(caller) do
+        assert_equal 1, subject.error_results.size, 'too many/few error results'
+        test.error_results.each do |result|
+          assert_kind_of Assert::Result::Error, result, 'result is not an error result'
+        end
+        assert_equal test.error_results.size, test.result_count(:error), 'error result not counted'
       end
-      assert_equal subject.error_results.size, subject.result_count(:error)
+    end
+
+  end
+
+  class SignalExceptionHandlingTests < BasicTests
+    setup do
+      @test = Factory.test("signal test", @context_info) do
+        raise SignalException, "USR1"
+      end
+    end
+    subject{ @test }
+
+    should "raise any signal exceptions and not capture as an error" do
+      assert_raises(SignalException){ subject.run }
+    end
+
+    should "raises signal exceptions in the context setup" do
+      test = Factory.test("setup signal test", @context_info){ }
+      test.context_class.setup{ raise SignalException, 'INT' }
+
+      assert_raises(SignalException){ test.run }
+    end
+
+    should "raises signal exceptions in the context teardown" do
+      test = Factory.test("teardown signal test", @context_info){ }
+      test.context_class.teardown{ raise SignalException, "TERM" }
+
+      assert_raises(SignalException){ test.run }
     end
 
   end
@@ -157,10 +238,10 @@ class Assert::Test
   class CaptureOutTests < BasicTests
     desc "when capturing std out"
     setup do
-      @test = Factory.test("stdout") {
+      @test = Factory.test("stdout") do
         puts "std out from the test"
         assert true
-      }
+      end
       @orig_capture = Assert.config.capture_output
       Assert.config.capture_output true
     end
@@ -182,8 +263,8 @@ class Assert::Test
         puts "std out from the test"
         assert a_method_an_assert_calls
       end
-      @test.context_class.setup { puts "std out from the setup" }
-      @test.context_class.teardown { puts "std out from the teardown" }
+      @test.context_class.setup{ puts "std out from the setup" }
+      @test.context_class.teardown{ puts "std out from the teardown" }
       @test.context_class.send(:define_method, "a_method_an_assert_calls") do
         puts "std out from a method an assert called"
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assert
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 7
   prerelease: 
   segments: 
   - 2
   - 3
-  - 1
-  version: 2.3.1
+  - 2
+  version: 2.3.2
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-10-03 00:00:00 Z
+date: 2013-10-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ansi