dohtest 0.1.6 → 0.1.7

data/lib/doh/test/assertions.rb

@@ -1,55 +1,62 @@
-module DohTest
+require 'doh/test/failure'
 
-AssertionFailed = Class.new(StandardError)
+module DohTest
 
 class TestGroup
-  def assert(condition, msg = nil)
-    if condition
+  def assert(boolean, msg = nil)
+    if boolean
       @runner.assertion_passed
     else
-      raise DohTest::AssertionFailed, msg || "Assertion failed."
+      raise DohTest::Failure.new(msg, :boolean, nil, nil)
     end
   end
 
-  def build_equal_msg(expected, actual)
-    if (expected.to_s.size + actual.to_s.size) < 50
-      "expected: #{expected}; actual: #{actual}"
+  def assert_equal(expected, actual, msg = nil)
+    if expected == actual
+      @runner.assertion_passed
     else
-      "\nexpected: #{expected}\n  actual: #{actual}"
+      raise DohTest::Failure.new(msg, :equal, expected, actual)
     end
   end
 
-  def assert_equal(expected, actual, msg = nil)
-    assert(expected == actual, msg || build_equal_msg(expected, actual))
-  end
-
-  def assert_raises(*args)
-    msg = args.pop if args.last.is_a?(String)
-
+  def assert_raises(*expected)
+    msg = expected.pop if expected.last.is_a?(String)
     begin
       yield
       no_exception = true
-    rescue Exception => excpt
-      expected_str = if (args.size == 1) then args.first else "one of #{args.join(',')}" end
-      assert(args.include?(excpt.class), msg || "expected: #{expected_str}; actual: #{excpt.class}: #{excpt.message}")
-      return
-    end
-
-    if no_exception
-      raise DohTest::AssertionFailed, msg || "expected: #{args}, but no exception was raised"
+    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 }
+        @runner.assertion_passed
+      else
+        raise DohTest::Failure.new(msg, :raises, expected, actual_class)
+      end
     end
+    raise DohTest::Failure.new(msg, :raises, expected, nil) if no_exception
   end
 
   def assert_instance_of(expected_class, actual_object, msg = nil)
-    assert(actual_object.instance_of?(expected_class), msg || "expected class: #{expected_class}; actual: #{actual_object.class}")
+    if actual_object.instance_of?(expected_class)
+      @runner.assertion_passed
+    else
+      raise DohTest::Failure.new(msg, :instance_of, expected_class, actual_object)
+    end
   end
 
   def assert_match(expected_regex, actual_str, msg = nil)
-    assert(actual_str.match(expected_regex), msg || "expected regex #{expected_regex} to match str: #{actual_str}")
+    if actual_str.match(expected_regex)
+      @runner.assertion_passed
+    else
+      raise DohTest::Failure.new(msg, :match, expected_regex, actual_str)
+    end
   end
 
   def assert_not_equal(expected, actual, msg = nil)
-    assert(expected != actual, msg || "expected unequal values")
+    if expected != actual
+      @runner.assertion_passed
+    else
+      raise DohTest::Failure.new(msg, :not_equal, expected, actual)
+    end
   end
 end
 

data/lib/doh/test/capture_output.rb

@@ -0,0 +1,53 @@
+module DohTest
+
+class CaptureOutput
+  attr_reader :events
+
+  def initialize
+    @events = []
+  end
+
+  def run_begin(config)
+    add(:config => config)
+  end
+
+  def run_end(duration)
+    add(:duration => duration)
+  end
+
+  def group_begin(group_name)
+    add(:group_name => group_name)
+  end
+
+  def group_end(group_name, tests_ran, tests_skipped, assertions_passed, assertions_failed)
+    add(:group_name => group_name, :tests_ran => tests_ran, :tests_skipped => tests_skipped, :assertions_passed => assertions_passed, :assertions_failed => assertions_failed)
+  end
+
+  def test_begin(group_name, test_name)
+    add(:group_name => group_name, :test_name => test_name)
+  end
+
+  def test_end(group_name, test_name)
+    add(:group_name => group_name, :test_name => test_name)
+  end
+
+  def test_error(group_name, test_name, error)
+    add(:group_name => group_name, :test_name => test_name, :error => error)
+  end
+
+  def assertion_failed(group_name, test_name, failure)
+    add(:group_name => group_name, :test_name => test_name, :failure => failure)
+  end
+
+  def assertion_passed(group_name, test_name)
+    add(:group_name => group_name, :test_name => test_name)
+  end
+
+private
+  def add(args)
+    args[:name] = caller.first.rpartition(':in ').last[1..-2]
+    @events.push(args)
+  end
+end
+
+end

data/lib/doh/test/failure.rb

@@ -0,0 +1,12 @@
+module DohTest
+
+class Failure < StandardError
+  attr_reader :assert, :expected, :actual
+
+  def initialize(message, assert, expected, actual)
+    super(message || '')
+    @assert, @expected, @actual = assert, expected, actual
+  end
+end
+
+end

data/lib/doh/test/group_runner.rb

@@ -7,64 +7,120 @@ class GroupRunner
     @group_class,@output = group_class,output
     @config = config || {}
     @group_name = @group_class.to_s
-    @group_failed = false
-    @tests_ran = 0
-    @tests_skipped = 0
-    @assertions_passed = 0
-    @assertions_failed = 0
+    @before_all_failed = false
+    @error_count = @tests_ran = @tests_skipped = @assertions_failed = @assertions_passed = 0
   end
 
   def run
     @output.group_begin(@group_name)
-    create_group
-    run_before_all unless @group_failed
-    run_tests unless @group_failed
-    run_after_all unless @group_failed
+    if create_group
+      run_before_all
+      run_tests unless @before_all_failed
+      run_after_all
+    end
     @output.group_end(@group_name, @tests_ran, @tests_skipped, @assertions_passed, @assertions_failed)
+    past_brink?
   end
 
   def create_group
     @group = @group_class.new
   rescue => error
-    @group_failed = true
-    @output.test_error(@group_name, 'initialize', error)
+    caught_error(error, 'initialize')
+    false
   else
     @group.runner = self
+    true
   end
 
   def run_before_all
     @group.before_all if @group.respond_to?(:before_all)
   rescue => error
-    @group_failed = true
-    @output.test_error(@group_name, 'before_all', error)
+    @before_all_failed = true
+    caught_error(error, 'before_all')
   end
 
   def run_after_all
     @group.after_all if @group.respond_to?(:after_all)
   rescue => error
-    @output.test_error(@group_name, 'after_all', error)
+    caught_error(error, 'after_all')
   end
 
-  def run_tests
-    determine_test_methods
+  def find_before_each_method
     has_before_each = @group.respond_to?(:before_each)
+    has_setup = @group.respond_to?(:setup)
+    if has_before_each && has_setup
+      raise ":before_each and :setup both defined; please pick one"
+    elsif has_before_each
+      @before_each_method = :before_each
+    elsif has_setup
+      @before_each_method = :setup
+    else
+      @before_each_method = nil
+    end
+  end
+
+  def find_after_each_method
     has_after_each = @group.respond_to?(:after_each)
+    has_teardown = @group.respond_to?(:teardown)
+    if has_after_each && has_teardown
+      raise ":after_each and :teardown both defined; please pick one"
+    elsif has_after_each
+      @after_each_method = :after_each
+    elsif has_teardown
+      @after_each_method = :teardown
+    else
+      @after_each_method = nil
+    end
+  end
+
+  def run_before_each
+    @group.send(@before_each_method)
+  rescue => error
+    @before_each_failed = true
+    caught_error(error)
+  end
+
+  def run_after_each
+    @group.send(@after_each_method)
+  rescue => error
+    caught_error(error)
+  end
+
+  def run_test_method
+    @group.send(@test_name)
+  rescue DohTest::Failure => failure
+    @assertions_failed += 1
+    @output.assertion_failed(@group_name, @test_name, failure)
+  rescue => error
+    caught_error(error)
+  end
+
+  def setup_brink
+    @max_errors = if @config.key?(:max_errors) then @config[:max_errors].to_i else nil end
+    @max_failures = if @config.key?(:max_failures) then @config[:max_failures].to_i else nil end
+    @has_brink = @max_errors || @max_failures
+  end
+
+  def past_brink?
+    (@max_errors && (@error_count > @max_errors)) || (@max_failures && (@assertions_failed > @max_failures))
+  end
+
+  def run_tests
+    determine_test_methods
+    find_before_each_method
+    find_after_each_method
+    setup_brink
 
     @test_methods.each do |method_name|
+      break if @has_brink && past_brink?
       @test_name = method_name
-      begin
-        @group.send(:before_each) if has_before_each
-        @output.test_begin(@group_name, @test_name)
-        @group.send(@test_name)
-        @tests_ran += 1
-        @output.test_end(@group_name, @test_name)
-        @group.send(:after_each) if has_after_each
-      rescue DohTest::AssertionFailed => failure
-        @assertions_failed += 1
-        @output.assertion_failed(@group_name, @test_name, failure)
-      rescue => error
-        @output.test_error(@group_name, @test_name, error)
-      end
+      @before_each_failed = false
+      @output.test_begin(@group_name, @test_name)
+      run_before_each if @before_each_method
+      run_test_method unless @before_each_failed
+      run_after_each if @after_each_method
+      @tests_ran += 1
+      @output.test_end(@group_name, @test_name)
     end
   end
 
@@ -81,6 +137,11 @@ class GroupRunner
     @assertions_passed += 1
     @output.assertion_passed(@group_name, @test_name)
   end
+
+  def caught_error(error, test_name = nil)
+    @error_count += 1
+    @output.test_error(@group_name, test_name || @test_name, error)
+  end
 end
 
 end

data/lib/doh/test/master_runner.rb

@@ -13,7 +13,9 @@ class MasterRunner
     DohTest::require_paths(@config[:glob], @paths)
     srand(@config[:seed])
     @output.run_begin(@config)
-    TestGroup.descendants.each { |group_class| GroupRunner.new(group_class, @output, @config).run }
+    TestGroup.descendants.each do |group_class|
+      break if GroupRunner.new(group_class, @output, @config).run
+    end
     @output.run_end(Time.now - start_time)
   end
 end

data/lib/doh/test/stream_output.rb

@@ -75,13 +75,13 @@ class StreamOutput
   def test_error(group_name, test_name, error)
     @badness.add(group_name)
     @error_count += 1
-    display_badness('error', group_name, test_name, error, true)
+    display_badness(group_name, test_name, error)
   end
 
   def assertion_failed(group_name, test_name, failure)
     @badness.add(group_name)
     @assertions_failed += 1
-    display_badness('failure', group_name, test_name, failure, false)
+    display_badness(group_name, test_name, failure)
   end
 
   def assertion_passed(group_name, test_name)
@@ -89,18 +89,61 @@ class StreamOutput
   end
 
 private
-  def display_badness(title, group_name, test_name, excpt, display_name)
+  def display_badness(group_name, test_name, excpt)
+    badness_type = if excpt.is_a?(DohTest::Failure) then :failure else :error end
     parser = DohTest::BacktraceParser.new(excpt.backtrace)
-    warn "#{title} in #{group_name}.#{test_name}"
-    badname = if display_name then "#{excpt.class}: " else '' end
-    warn "=> #{badname}#{excpt}"
-    # main_call = parser.relevant_stack.last
-    # warn "=> #{main_call.first}:#{main_call.last}"
-    # warn "=> #{parser.summary}"
+    warn "#{badness_type} in #{group_name}.#{test_name}"
+    if badness_type == :error
+      warn "#{excpt.class}: #{excpt}"
+    else
+      display_failure_message(excpt)
+    end
     parser.relevant_stack.each do |path, line|
-      warn "=> #{path}:#{line}"
+      warn "#{path}:#{line}"
+    end
+  end
+
+  def display_failure_message(failure)
+    if failure.message.empty?
+      warn send("display_#{failure.assert}_failure", failure)
+    else
+      warn failure.message
+    end
+  end
+
+  def display_boolean_failure(failure)
+    "assertion failed"
+  end
+
+  def display_equal_failure(failure)
+    if (failure.expected.to_s.size + failure.actual.to_s.size) < 50
+      "expected: #{failure.expected}; actual: #{failure.actual}"
+    else
+      "\nexpected: #{failure.expected}\n  actual: #{failure.actual}"
     end
   end
+
+  def display_raises_failure(failure)
+    if failure.actual
+      expected_str = if (failure.expected.size == 1) then failure.expected.first else "one of #{failure.expected.join(',')}" end
+      "expected: #{expected_str}; actual: #{failure.actual.class}: #{failure.actual.message}"
+    else
+      "expected: #{failure.expected}, but no exception was raised"
+    end
+  end
+
+  def display_instance_of_failure(failure)
+    "expected class: #{failure.expected}; actual: #{failure.actual}"
+  end
+
+  def display_match_failure(failure)
+    "expected regex #{failure.expected} to match str: #{failure.actual}"
+  end
+
+  def display_not_equal_failure(failure)
+    "expected unequal values; both are: #{failure.expected}"
+  end
+
 end
 
 end

data/test/test_backtrace_parser.rb

@@ -1,5 +1,6 @@
+require 'doh/root'; Doh::find_root_from_file
 require 'minitest/autorun'
-require_relative '../lib/doh/test/backtrace_parser'
+require 'doh/test/backtrace_parser'
 
 module DohTest
 

data/test/test_group_runner.rb

@@ -0,0 +1,169 @@
+require 'doh/root'; Doh::find_root_from_file
+require 'minitest/autorun'
+require 'doh/test/group_runner'
+require 'doh/test/capture_output'
+
+module DohTest
+
+class TestGroupRunner < MiniTest::Unit::TestCase
+  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 {: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
+
+
+  class EmptyTestGroup < DohTest::TestGroup; end
+  def test_empty_group
+    run_group(EmptyTestGroup)
+    assert_equal(1, @events.size)
+    assert_equal({:name => 'group_end', :group_name => EmptyTestGroup.to_s, :tests_ran => 0, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 0}, @events.shift)
+  end
+
+  class SetupTeardownWithErrorGroup < DohTest::TestGroup
+    def initialize
+      @@ran_setup = @@ran_teardown = false
+    end
+
+    def setup
+      @@ran_setup = true
+    end
+
+    def teardown
+      @@ran_teardown = true
+    end
+
+    def test_just_an_error
+      raise "an error"
+    end
+  end
+
+  def test_setup_teardown_with_error
+    run_group(SetupTeardownWithErrorGroup)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    assert_equal('test_error', @events.shift[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 0}, @events.shift)
+    assert(@group_klass.class_variable_get(:@@ran_setup))
+    assert(@group_klass.class_variable_get(:@@ran_teardown))
+  end
+
+  class BeforeAfterWithErrorGroup < DohTest::TestGroup
+    def initialize
+      @@ran_before = @@ran_after = false
+    end
+
+    def before_each
+      @@ran_before = true
+    end
+
+    def after_each
+      @@ran_after = true
+    end
+
+    def test_just_an_error
+      raise "an error"
+    end
+  end
+
+  def test_before_after_with_error
+    run_group(BeforeAfterWithErrorGroup)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    assert_equal('test_error', @events.shift[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 0}, @events.shift)
+    assert(@group_klass.class_variable_get(:@@ran_before))
+    assert(@group_klass.class_variable_get(:@@ran_after))
+  end
+
+  class ErrorInBefore < DohTest::TestGroup
+    def initialize
+      @@ran_before = @@ran_test = @@ran_after = false
+    end
+
+    def before_each
+      @@ran_before = true
+      raise "blah"
+    end
+
+    def after_each
+      @@ran_after = true
+    end
+
+    def test_no_error
+      @@ran_test = true
+    end
+  end
+
+  def test_error_in_before
+    run_group(ErrorInBefore)
+    assert_equal(4, @events.size)
+    assert_equal('test_begin', @events.shift[:name])
+    assert_equal('test_error', @events.shift[:name])
+    assert_equal('test_end', @events.shift[:name])
+    verify_event({:tests_ran => 1, :tests_skipped => 0, :assertions_passed => 0, :assertions_failed => 0}, @events.shift)
+    assert(@group_klass.class_variable_get(:@@ran_before))
+    assert(!@group_klass.class_variable_get(:@@ran_test))
+    assert(@group_klass.class_variable_get(:@@ran_after))
+  end
+
+  class GreppingWithPass < DohTest::TestGroup
+    def test_blah
+      assert(true)
+    end
+    def test_blee
+      assert(true);assert(true)
+    end
+    def test_blahblah
+      assert(true);assert(true);assert(true)
+    end
+    def test_blahblee
+      assert(true);assert(true);assert(true);assert(true)
+    end
+    def test_blahbloo
+      assert(true);assert(true);assert(true);assert(true);assert(true)
+    end
+  end
+
+  def test_grepping_with_pass_no_grep
+    run_group(GreppingWithPass)
+    # group_end (1) + test_begin (5) + test_end (5) + assertion_passed (15)
+    assert_equal(26, @events.size)
+    verify_event({:tests_ran => 5, :tests_skipped => 0, :assertions_passed => 15, :assertions_failed => 0}, @events.last)
+  end
+
+  def test_grepping_with_pass_grep_blah
+    run_group(GreppingWithPass, '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')
+    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')
+    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')
+    verify_event({:tests_ran => 0, :tests_skipped => 5, :assertions_passed => 0, :assertions_failed => 0}, @events.last)
+  end
+end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dohtest
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-01 00:00:00.000000000Z
+date: 2012-03-14 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dohroot
-  requirement: &70365604410140 !ruby/object:Gem::Requirement
+  requirement: &70349766447240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,7 +22,7 @@ dependencies:
         version: 0.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *70365604410140
+  version_requirements: *70349766447240
 description: Minimalist unit test framework, easy to understand and extend.
 email:
 - devinfo@atpsoft.com
@@ -35,13 +35,16 @@ files:
 - bin/dohtest
 - lib/doh/test/assertions.rb
 - lib/doh/test/backtrace_parser.rb
+- lib/doh/test/capture_output.rb
 - lib/doh/test/configure.rb
+- lib/doh/test/failure.rb
 - lib/doh/test/group_runner.rb
 - lib/doh/test/master_runner.rb
 - lib/doh/test/require_paths.rb
 - lib/doh/test/stream_output.rb
 - lib/doh/test/test_group.rb
 - test/test_backtrace_parser.rb
+- test/test_group_runner.rb
 - MIT-LICENSE
 homepage: https://github.com/atpsoft/dohtest
 licenses:
@@ -70,4 +73,5 @@ specification_version: 3
 summary: minimalist unit test framework
 test_files:
 - test/test_backtrace_parser.rb
+- test/test_group_runner.rb
 has_rdoc: