dohtest 0.1.55 → 0.1.56

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfbc04ce3b53966d24d062b84ba569837f0b31e4d3a2f62a6fd1dd3b034816fa
-  data.tar.gz: 693a91b6c27c0b262bd2313850b9cccdb67969cec40aaf2d9797cf159dd606fe
+  metadata.gz: feef508b9e97ca382ecec3b01e7cb0c3ff609ab1e0e010e1d7676b94220f4840
+  data.tar.gz: 4fadcdffa88dc7d3d958c1f7b73a38a8897c3cfc9427ac32bc12031f2cc00fa1
 SHA512:
-  metadata.gz: 919fdd8ddd3a2e839d83ddda295340bb335842aa610c374da1938c2e73546608432b744dbd7636af5d727f570d3ad6754d0215e1fb9aba533bab7c2c7890b8fe
-  data.tar.gz: 30857a2fc0ab018f01e271e59186fb518e1485fed9b72d56236128663720c8df136eea427fc14771653a4b76c6cbeac24aa2cde209b18da80f86b9c4275682bc
+  metadata.gz: fe2f5fece8efb09b7fd77bbcf4169b992b22b73f66e876fba4763a23353763c1c291d08c9988e5852cd12710d48fe079e13f24f86e9a2995cac3941da0515d82
+  data.tar.gz: a36eaf21dbf9bc595fbf1a3eee95a77066d00dadc76bf5ecec20bb00ba8b81f8b809eb0a031e1f9df0d69044a90d59fd59ca0effe37edccbf43afb0ed16d5361

data/lib/dohtest/assertions.rb

@@ -19,20 +19,30 @@ class TestGroup
     end
   end
 
+  # expected arguments:
+  # one or more exception classes (or modules); a class matches only exactly, not a subclass
+  # then optionally a regex the exception's message must match
+  # then optionally a failure message to display if the assertion fails
   def assert_raises(*expected)
     msg = expected.pop if expected.last.is_a?(String)
+    message_regex = expected.pop if expected.last.is_a?(Regexp)
+    if expected.empty? || !expected.all? { |elem| elem.is_a?(Module) }
+      raise ArgumentError, "assert_raises takes exception classes, then an optional regex, then an optional failure message; got: #{expected.inspect}"
+    end
+    failure_expected = {:classes => expected, :message_regex => message_regex}
     begin
       yield
       no_exception = true
     rescue Exception => actual_excpt
       actual_class = actual_excpt.class
-      if expected.any? { |elem| elem.instance_of?(Module) ? actual_excpt.kind_of?(elem) : elem == actual_class }
+      class_matched = expected.any? { |elem| elem.instance_of?(Module) ? actual_excpt.kind_of?(elem) : elem == actual_class }
+      if class_matched && (message_regex.nil? || actual_excpt.message.match?(message_regex))
         @runner.assertion_passed
       else
-        raise DohTest::Failure.new(msg, :raises, expected, actual_excpt)
+        raise DohTest::Failure.new(msg, :raises, failure_expected, actual_excpt)
       end
     end
-    raise DohTest::Failure.new(msg, :raises, expected, nil) if no_exception
+    raise DohTest::Failure.new(msg, :raises, failure_expected, nil) if no_exception
   end
 
   def assert_instance_of(expected_class, actual_object, msg = nil)

data/lib/dohtest/capture_output.rb

@@ -35,17 +35,25 @@ class CaptureOutput
     add(:group_name => group_name, :test_name => test_name, :error => error, :seed => seed)
   end
 
-  def assertion_failed(group_name, test_name, failure)
-    add(:group_name => group_name, :test_name => test_name, :failure => failure)
+  def assertion_failed(group_name, test_name, failure, seed)
+    add(:group_name => group_name, :test_name => test_name, :failure => failure, :seed => seed)
   end
 
   def assertion_passed(group_name, test_name)
     add(:group_name => group_name, :test_name => test_name)
   end
 
+  def callback_failed(proc_name)
+    add(:proc_name => proc_name)
+  end
+
+  def no_tests_found
+    add({})
+  end
+
 private
   def add(args)
-    args[:name] = caller.first.rpartition(':in ').last[1..-2]
+    args[:name] = caller_locations(1, 1).first.base_label
     @events.push(args)
   end
 end

data/lib/dohtest/stream_output.rb

@@ -168,14 +168,25 @@ private
   end
 
   def display_raises_failure(failure)
+    classes = failure.expected.fetch(:classes)
+    message_regex = failure.expected.fetch(:message_regex)
+
+    if classes.size == 1
+      expected_str = classes.first.to_s
+    else
+      expected_str = "one of #{classes.join(',')}"
+    end
+
+    if message_regex
+      expected_str += " with message matching #{message_regex.inspect}"
+    end
     if failure.actual
-      expected_str = if (failure.expected.size == 1) then failure.expected.first else "one of #{failure.expected.join(',')}" end
       @err_ios.puts colorize(:info, "expected: #{expected_str}; actual: #{failure.actual.class}: #{failure.actual.message}")
       DohTest::BacktraceParser.new(failure.actual.backtrace).relevant_stack.each do |path, line|
         @err_ios.puts "#{path}:#{line}"
       end
     else
-      @err_ios.puts colorize(:info, "expected: #{failure.expected}, but no exception was raised")
+      @err_ios.puts colorize(:info, "expected: #{expected_str}, but no exception was raised")
     end
   end
 

data/test/support/group_runner_helper.rb

@@ -0,0 +1,25 @@
+require 'dohtest/group_runner'
+require 'dohtest/capture_output'
+
+module DohTest
+
+# runs a test group with CaptureOutput, so a Minitest::Test can check the events it reports
+module GroupRunnerHelper
+  def verify_event(expected_pairs, event)
+    expected_pairs.each_pair do |key, value|
+      assert_equal(value, event[key])
+    end
+  end
+
+  def run_group(group_klass, config_overrides = {})
+    @group_klass = group_klass
+    @output = CaptureOutput.new
+    @runner = GroupRunner.new(@group_klass, @output, DohTest.config.merge(config_overrides))
+    @runner.run
+    @events = @output.events
+    assert_equal({:name => 'group_begin', :group_name => @group_klass.to_s}, @events.shift)
+    verify_event({:name => 'group_end', :group_name => @group_klass.to_s}, @events.last)
+  end
+end
+
+end

data/test/test_assertions.rb

@@ -0,0 +1,239 @@
+require 'dohroot'; Doh.find_root_from_file
+require 'minitest/autorun'
+require 'dohtest/group_runner'
+require 'dohtest/capture_output'
+require File.join(Doh.root, 'test/support/group_runner_helper')
+
+module DohTest
+
+class TestAssertions < Minitest::Test
+  include GroupRunnerHelper
+
+  def verify_passed(group_klass)
+    run_group(group_klass)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    assert_equal('assertion_passed', @events.shift[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 1, :assertions_failed => 0}, @events.shift)
+  end
+
+  def run_failed_group(group_klass)
+    run_group(group_klass)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    event = @events.shift
+    assert_equal('assertion_failed', event[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 1}, @events.shift)
+    assert_equal(:raises, event[:failure].assert)
+    return event[:failure]
+  end
+
+  def verify_argument_error(group_klass)
+    run_group(group_klass)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    event = @events.shift
+    assert_equal('test_error', event[:name])
+    assert_equal(ArgumentError, event[:error].class)
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 0}, @events.shift)
+  end
+
+  class RaisesClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_class
+    verify_passed(RaisesClass)
+  end
+
+  class RaisesOneOfSeveralClasses < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError, ArgumentError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_one_of_several_classes
+    verify_passed(RaisesOneOfSeveralClasses)
+  end
+
+  module TaggedError; end
+  class TaggedRuntimeError < RuntimeError
+    include TaggedError
+  end
+
+  class RaisesModule < DohTest::TestGroup
+    def test_raises
+      assert_raises(TaggedError) { raise TaggedRuntimeError }
+    end
+  end
+
+  def test_raises_module
+    verify_passed(RaisesModule)
+  end
+
+  class RaisesWrongClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_wrong_class
+    failure = run_failed_group(RaisesWrongClass)
+    assert_equal(ArgumentError, failure.actual.class)
+  end
+
+  class RaisesSubclass < DohTest::TestGroup
+    def test_raises
+      assert_raises(StandardError) { raise ArgumentError }
+    end
+  end
+
+  def test_raises_subclass
+    failure = run_failed_group(RaisesSubclass)
+    assert_equal(ArgumentError, failure.actual.class)
+  end
+
+  class RaisesNothing < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError) { nil }
+    end
+  end
+
+  def test_raises_nothing
+    failure = run_failed_group(RaisesNothing)
+    assert_nil(failure.actual)
+  end
+
+  class RaisesMatchingMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/) { raise ArgumentError, 'xx abc xx' }
+    end
+  end
+
+  def test_raises_matching_message
+    verify_passed(RaisesMatchingMessage)
+  end
+
+  class RaisesNonMatchingMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/) { raise ArgumentError, 'xyz' }
+    end
+  end
+
+  def test_raises_non_matching_message
+    failure = run_failed_group(RaisesNonMatchingMessage)
+    assert_equal('xyz', failure.actual.message)
+    assert_equal({:classes => [ArgumentError], :message_regex => /abc/}, failure.expected)
+  end
+
+  class RaisesMatchingMessageWrongClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError, /abc/) { raise ArgumentError, 'abc' }
+    end
+  end
+
+  def test_raises_matching_message_wrong_class
+    failure = run_failed_group(RaisesMatchingMessageWrongClass)
+    assert_equal(ArgumentError, failure.actual.class)
+  end
+
+  class RaisesNothingWithRegex < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/) { nil }
+    end
+  end
+
+  def test_raises_nothing_with_regex
+    failure = run_failed_group(RaisesNothingWithRegex)
+    assert_nil(failure.actual)
+  end
+
+  class RaisesWithFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(TypeError, 'custom message') { raise ArgumentError }
+    end
+  end
+
+  def test_raises_with_failure_message
+    failure = run_failed_group(RaisesWithFailureMessage)
+    assert_equal('custom message', failure.message)
+  end
+
+  class RaisesWithRegexAndFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, /abc/, 'custom message') { raise ArgumentError, 'xyz' }
+    end
+  end
+
+  def test_raises_with_regex_and_failure_message
+    failure = run_failed_group(RaisesWithRegexAndFailureMessage)
+    assert_equal('custom message', failure.message)
+  end
+
+  class RaisesNoArguments < DohTest::TestGroup
+    def test_raises
+      assert_raises { nil }
+    end
+  end
+
+  def test_raises_no_arguments
+    verify_argument_error(RaisesNoArguments)
+  end
+
+  class RaisesOnlyRegex < DohTest::TestGroup
+    def test_raises
+      assert_raises(/abc/) { nil }
+    end
+  end
+
+  def test_raises_only_regex
+    verify_argument_error(RaisesOnlyRegex)
+  end
+
+  class RaisesOnlyFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises('custom message') { nil }
+    end
+  end
+
+  def test_raises_only_failure_message
+    verify_argument_error(RaisesOnlyFailureMessage)
+  end
+
+  class RaisesRegexBeforeClass < DohTest::TestGroup
+    def test_raises
+      assert_raises(/abc/, ArgumentError) { nil }
+    end
+  end
+
+  def test_raises_regex_before_class
+    verify_argument_error(RaisesRegexBeforeClass)
+  end
+
+  class RaisesRegexAfterFailureMessage < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, 'custom message', /abc/) { nil }
+    end
+  end
+
+  def test_raises_regex_after_failure_message
+    verify_argument_error(RaisesRegexAfterFailureMessage)
+  end
+
+  class RaisesNonClassArgument < DohTest::TestGroup
+    def test_raises
+      assert_raises(ArgumentError, 5) { nil }
+    end
+  end
+
+  def test_raises_non_class_argument
+    verify_argument_error(RaisesNonClassArgument)
+  end
+end
+
+end

data/test/test_group_runner.rb

@@ -2,27 +2,12 @@ require 'dohroot'; Doh.find_root_from_file
 require 'minitest/autorun'
 require 'dohtest/group_runner'
 require 'dohtest/capture_output'
+require File.join(Doh.root, 'test/support/group_runner_helper')
 
 module DohTest
 
 class TestGroupRunner < Minitest::Test
-  def verify_event(expected_pairs, event)
-    expected_pairs.each_pair do |key, value|
-      assert_equal(value, event[key])
-    end
-  end
-
-  def run_group(group_klass, grepstr = nil)
-    @group_klass = group_klass
-    @output = CaptureOutput.new
-    config = if grepstr then DohTest.config.merge({:grep => grepstr}) else nil end
-    @runner = GroupRunner.new(@group_klass, @output, config)
-    @runner.run
-    @events = @output.events
-    assert_equal({:name => 'group_begin', :group_name => @group_klass.to_s}, @events.shift)
-    verify_event({:name => 'group_end', :group_name => @group_klass.to_s}, @events.last)
-  end
-
+  include GroupRunnerHelper
 
   class EmptyTestGroup < DohTest::TestGroup; end
   def test_empty_group
@@ -120,6 +105,39 @@ class TestGroupRunner < Minitest::Test
     assert(@group_klass.class_variable_get(:@@ran_after))
   end
 
+  class AssertionFailureGroup < DohTest::TestGroup
+    def test_failed_assertion
+      assert_equal(1, 2)
+    end
+  end
+
+  def test_assertion_failure
+    run_group(AssertionFailureGroup)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    event = @events.shift
+    assert_equal('assertion_failed', event[:name])
+    assert_equal(:equal, event[:failure].assert)
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 1}, @events.shift)
+  end
+
+  class CallbackFailureGroup < DohTest::TestGroup
+    def test_pass
+      assert(true)
+    end
+  end
+
+  def test_callback_failure
+    run_group(CallbackFailureGroup, :pre_group_callback => [proc { false }])
+    assert_equal(5, @events.size)
+    assert_equal('callback_failed', @events.shift[:name])
+    assert_equal('test_begin', @events.shift[:name])
+    assert_equal('assertion_passed', @events.shift[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 1, :assertions_failed => 0}, @events.shift)
+  end
+
   class GreppingWithPass < DohTest::TestGroup
     def test_blah
       assert(true)
@@ -146,22 +164,22 @@ class TestGroupRunner < Minitest::Test
   end
 
   def test_grepping_with_pass_grep_blah
-    run_group(GreppingWithPass, 'blah')
+    run_group(GreppingWithPass, :grep => 'blah')
     verify_event({:tests_ran => 4, :tests_skipped => 1, :assertions_passed => 13, :assertions_failed => 0}, @events.last)
   end
 
   def test_grepping_with_pass_grep_blee
-    run_group(GreppingWithPass, 'blee')
+    run_group(GreppingWithPass, :grep => 'blee')
     verify_event({:tests_ran => 2, :tests_skipped => 3, :assertions_passed => 6, :assertions_failed => 0}, @events.last)
   end
 
   def test_grepping_with_pass_grep_bloo
-    run_group(GreppingWithPass, 'bloo')
+    run_group(GreppingWithPass, :grep => 'bloo')
     verify_event({:tests_ran => 1, :tests_skipped => 4, :assertions_passed => 5, :assertions_failed => 0}, @events.last)
   end
 
   def test_grepping_with_pass_grep_zzz
-    run_group(GreppingWithPass, 'zzz')
+    run_group(GreppingWithPass, :grep => 'zzz')
     verify_event({:tests_ran => 0, :tests_skipped => 5, :assertions_passed => 0, :assertions_failed => 0}, @events.last)
   end
 end

data/test/test_master_runner.rb

@@ -0,0 +1,20 @@
+require 'dohroot'; Doh.find_root_from_file
+require 'minitest/autorun'
+require 'dohtest/master_runner'
+require 'dohtest/capture_output'
+
+module DohTest
+
+class TestMasterRunner < Minitest::Test
+  def test_no_tests_found
+    output = CaptureOutput.new
+    runner = MasterRunner.new(output, DohTest.config.merge(:test_files => [], :seed => 1))
+    assert_equal(1, runner.run)
+    events = output.events
+    assert_equal(2, events.size)
+    assert_equal('run_begin', events.shift[:name])
+    assert_equal('no_tests_found', events.shift[:name])
+  end
+end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dohtest
 version: !ruby/object:Gem::Version
-  version: 0.1.55
+  version: 0.1.56
 platform: ruby
 authors:
 - ATPSoft
@@ -62,9 +62,12 @@ files:
 - lib/dohtest/master_runner.rb
 - lib/dohtest/stream_output.rb
 - lib/dohtest/test_group.rb
+- test/support/group_runner_helper.rb
+- test/test_assertions.rb
 - test/test_backtrace_parser.rb
 - test/test_exit_codes.rb
 - test/test_group_runner.rb
+- test/test_master_runner.rb
 homepage: https://github.com/atpsoft/dohtest
 licenses:
 - MIT
@@ -87,6 +90,9 @@ rubygems_version: 4.0.17
 specification_version: 4
 summary: minimalist unit test framework
 test_files:
+- test/support/group_runner_helper.rb
+- test/test_assertions.rb
 - test/test_backtrace_parser.rb
 - test/test_exit_codes.rb
 - test/test_group_runner.rb
+- test/test_master_runner.rb