dohtest 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Makani Mason, Kem Mason
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/dohtest

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'doh/options'
+require 'doh/test/master_runner'
+require 'doh/test/stream_output'
+
+opts = Doh::Options.new(
+{'grep' => [nil, "-g", "--grep <name>", "only execute tests with name that include the given value"] \
+,'glob' => ['*.dt.rb', "-b", "--glob <string>", "glob string to find test files"] \
+,'seed' => [nil, "-v", "--seed <number>", "random seed"] \
+}, true, 'Files or directories may be specified to run tests on.  Directories will be treated recursively.  Defaults to the current directory.')
+
+config = {}
+config[:grep] = opts.grep if opts.grep
+config[:glob] = opts.glob
+config[:seed] = opts.seed.to_i if opts.seed
+config[:paths] = (if opts.varargs.empty? then ['.'] else opts.varargs end)
+
+exit DohTest::MasterRunner.new(DohTest::StreamOutput.new, config).run

data/lib/doh/test/assertions.rb

@@ -0,0 +1,55 @@
+module DohTest
+
+AssertionFailed = Class.new(StandardError)
+
+class TestGroup
+  def assert(condition, msg = nil)
+    if condition
+      @runner.assertion_passed
+    else
+      raise DohTest::AssertionFailed, msg || "Assertion failed."
+    end
+  end
+
+  def build_equal_msg(expected, actual)
+    if (expected.to_s.size + actual.to_s.size) < 50
+      "expected: #{expected}; actual: #{actual}"
+    else
+      "\nexpected: #{expected}\n  actual: #{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)
+
+    begin
+      yield
+      no_exception = true
+    rescue Exception => excpt
+      assert(args.include?(excpt.class), msg || "expected: #{args}; actual: #{excpt}")
+      return
+    end
+
+    if no_exception
+      raise DohTest::AssertionFailed, msg || "expected: #{args}, but no exception was raised"
+    end
+  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}")
+  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}")
+  end
+
+  def assert_not_equal(expected, actual, msg = nil)
+    assert(expected != actual, msg || "expected unequal values")
+  end
+end
+
+end

data/lib/doh/test/backtrace_parser.rb

@@ -0,0 +1,64 @@
+module DohTest
+
+class BacktraceParser
+  def initialize(backtrace)
+    @backtrace = backtrace
+  end
+
+  def relevant_stack
+    @relevant_stack ||= find_relevant_stack
+  end
+
+  def summary
+    @summary ||= build_summary
+  end
+
+private
+  def find_relevant_stack
+    retval = []
+    found_start = false
+    @backtrace.each do |location|
+      has_doh_test = location.index('doh/test')
+      if found_start && has_doh_test
+        break
+      elsif has_doh_test
+        # just ignore it and continue
+      else
+        found_start = true
+        info = location.rpartition(':in').first
+        retval << info
+      end
+    end
+    retval
+  end
+
+  def build_summary
+    retval = ''
+    prev_filename = ''
+    prev_simplified = ''
+    relevant_stack.each do |location|
+      parts = location.partition(':')
+      filename = File.basename(parts.first)
+      simplified = "#{filename}:#{parts.last}"
+      raise "unexpected location format: #{location}" unless filename
+      if simplified == prev_simplified
+        # ignore it
+      elsif filename == prev_filename
+        retval += ",#{parts.last}"
+      elsif retval.empty?
+        retval = simplified
+      else
+        retval += ";#{simplified}"
+      end
+      prev_filename = filename
+      prev_simplified = simplified
+    end
+    retval
+  end
+end
+
+def self.backtrace_summary(excpt)
+  BacktraceParser.new(excpt.backtrace).summary
+end
+
+end

data/lib/doh/test/configure.rb

@@ -0,0 +1,18 @@
+require 'doh/root'
+
+module DohTest
+
+def self.configure(start_path)
+  start_directory = File.dirname(start_path)
+
+  root_directory = Doh::find_root(start_directory)
+  if root_directory
+    root_filename = File.join(root_directory, 'config', 'dohtest.rb')
+    require(root_filename) if File.exist?(root_filename)
+  end
+
+  local_filename = Doh::findup(start_directory, 'configure_dohtest.rb')
+  require(local_filename) if local_filename && File.exist?(local_filename)
+end
+
+end

data/lib/doh/test/group_runner.rb

@@ -0,0 +1,79 @@
+require 'doh/test/test_group'
+
+module DohTest
+
+class GroupRunner
+  def initialize(group_class, output, config = nil)
+    @group_class,@output = group_class,output
+    @config = config || {}
+    @group_name = @group_class.to_s
+    @group_failed = false
+  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
+    @output.group_end(@group_name)
+  end
+
+  def create_group
+    @group = @group_class.new
+  rescue => error
+    @group_failed = true
+    @output.test_error(@group_name, 'initialize', error)
+  else
+    @group.runner = self
+  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)
+  end
+
+  def run_after_all
+    @group.after_all if @group.respond_to?(:after_all)
+  rescue => error
+    @output.test_error(@group_name, 'after_all', error)
+  end
+
+  def run_tests
+    determine_test_methods
+    has_before_each = @group.respond_to?(:before_each)
+    has_after_each = @group.respond_to?(:after_each)
+
+    @test_methods.each do |method_name|
+      @test_name = method_name
+      begin
+        @group.send(:before_each) if has_before_each
+        @output.test_begin(@group_name, @test_name)
+        @group.send(@test_name)
+        @output.test_end(@group_name, @test_name)
+        @group.send(:after_each) if has_after_each
+      rescue DohTest::AssertionFailed => failure
+        @output.assertion_failed(@group_name, @test_name, failure)
+      rescue => error
+        @output.test_error(@group_name, @test_name, error)
+      end
+    end
+  end
+
+  def determine_test_methods
+    @test_methods = @group_class.public_instance_methods.grep(/^test/)
+    original_test_count = @test_methods.size
+    return unless @config.key?(:grep)
+    grep_filter = Regexp.new(@config[:grep])
+    @test_methods.select! { |method| name.to_s =~ grep_filter }
+    @output.tests_skipped(@group_name, original_test_count - @test_methods.size)
+  end
+
+  def assertion_passed
+    @output.assertion_passed(@group_name, @test_name)
+  end
+end
+
+end

data/lib/doh/test/master_runner.rb

@@ -0,0 +1,31 @@
+require 'doh/test/configure'
+require 'doh/test/group_runner'
+require 'doh/test/require_paths'
+
+module DohTest
+
+class MasterRunner
+  def initialize(output, config)
+    @output, @config = output, config
+    add_missing_config
+  end
+
+  def run
+    paths = @config[:paths]
+    DohTest::configure(paths[0])
+    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 }
+    @output.run_end
+  end
+
+private
+  def add_missing_config
+    @config[:glob] ||= '*.dt.rb'
+    @config[:seed] ||= (Time.new.to_f * 1000).to_i
+    @config[:paths] ||= ['.']
+  end
+end
+
+end

data/lib/doh/test/require_paths.rb

@@ -0,0 +1,13 @@
+module DohTest
+
+def self.require_paths(glob, paths)
+  paths.collect {|elem| File.expand_path(elem) }.each do |onepath|
+    if File.directory?(onepath)
+      Dir.glob(File.join(onepath, '**', glob)).each {|filename| require(filename)}
+    else
+      require(File.expand_path(onepath))
+    end
+  end
+end
+
+end

data/lib/doh/test/stream_output.rb

@@ -0,0 +1,67 @@
+require 'doh/test/backtrace_parser'
+require 'set'
+
+module DohTest
+
+class StreamOutput
+  def initialize
+    @error_count = @group_cnt = @tests_ran = @tests_skipped = @assertions_failed = @assertions_passed = 0
+    @badness = Set.new
+  end
+
+  def run_begin(config)
+    puts "running tests with config: #{config}"
+  end
+
+  def run_end
+    total_assertions = @assertions_passed + @assertions_failed
+    puts "\n\n#@error_count errors, #@group_cnt groups, #@tests_ran tests, #{@tests_skipped} skipped, #{total_assertions} assertions, #@assertions_passed passed, #@assertions_failed failed"
+    puts "completed in 0.043702s, 22.8822 tests/s, 45.7645 assertions/s <TODO: put real values here>"
+    # this is to generate an exit code; true translates to 0, false to 1
+    @error_count == 0 && @assertions_failed == 0
+  end
+
+  def group_begin(group_name)
+    @group_cnt += 1
+  end
+
+  def group_end(group_name)
+    puts "success in #{group_name}" unless @badness.include?(group_name)
+  end
+
+  def tests_skipped(group_name, count)
+    @tests_skipped += count
+  end
+
+  def test_begin(group_name, test_name)
+  end
+
+  def test_end(group_name, test_name)
+    @tests_ran += 1
+  end
+
+  def test_error(group_name, test_name, error)
+    @badness.add(group_name)
+    @error_count += 1
+    display_badness('error', group_name, test_name, error, true)
+  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)
+  end
+
+  def assertion_passed(group_name, test_name)
+    @assertions_passed += 1
+  end
+
+private
+  def display_badness(title, group_name, test_name, excpt, display_name)
+    warn "#{title} in #{group_name}.#{test_name} at #{DohTest::backtrace_summary(excpt)}"
+    badname = if display_name then "#{excpt.class}: " else '' end
+    warn "=> #{badname}#{excpt}"
+  end
+end
+
+end

data/lib/doh/test/test_group.rb

@@ -0,0 +1,17 @@
+require 'doh/test/assertions'
+
+module DohTest
+
+class TestGroup
+  def self.descendants
+    @@descendants ||= []
+  end
+
+  def self.inherited(descendant)
+    descendants << descendant
+  end
+
+  attr_writer :runner
+end
+
+end

data/test/test_backtrace_parser.rb

@@ -0,0 +1,77 @@
+require 'minitest/autorun'
+require_relative '../lib/doh/test/backtrace_parser'
+
+module DohTest
+
+class TestBacktraceParser < MiniTest::Unit::TestCase
+  def create_single_stack
+    retval = []
+    retval << "/Users/somebody/dohtest/lib/doh/test/assertions.rb:10:in `assert'"
+    retval << "/Users/somebody/dohtest/lib/doh/test/assertions.rb:15:in `assert_equal'"
+    retval << "/Users/somebody/tinker/test/frog.rb:12:in `test_thing'"
+    retval << "/Users/somebody/dohtest/lib/doh/test/group_runner.rb:28:in `block in run_group'"
+    retval << "/Users/somebody/dohtest/lib/doh/test/group_runner.rb:12:in `each'"
+    retval << "/Users/somebody/dohtest/lib/doh/test/group_runner.rb:12:in `run'"
+    retval << "/Users/somebody/dohtest/bin/dohtest:24:in `<main>'"
+    retval
+  end
+
+  def test_single_stack
+    location = DohTest::BacktraceParser.new(create_single_stack).summary
+    assert_equal("frog.rb:12", location)
+  end
+
+  def create_double_stack
+    retval = []
+    retval << "/Users/somebody/dohtest/lib/doh/test/assertions.rb:10:in `assert'"
+    retval << "/Users/somebody/tinker/test/frog.rb:5:in `verify_sum'"
+    retval << "/Users/somebody/tinker/test/frog.rb:12:in `test_thing'"
+    retval << "/Users/somebody/dohtest/lib/doh/test/group_runner.rb:28:in `block in run_group'"
+    retval
+  end
+
+  def test_double_stack
+    location = DohTest::BacktraceParser.new(create_double_stack).summary
+    assert_equal("frog.rb:5,12", location)
+  end
+
+  def create_multifile_stack
+    retval = []
+    retval << "/Users/somebody/dohtest/lib/doh/test/assertions.rb:10:in `assert'"
+    retval << "/Users/somebody/tinker/helpers/toad.rb:8:in `verify_sum'"
+    retval << "/Users/somebody/tinker/test/frog.rb:11:in `test_thing'"
+    retval << "/Users/somebody/dohtest/lib/doh/test/group_runner.rb:28:in `block in run_group'"
+    retval
+  end
+
+  def test_multifile_stack
+    location = DohTest::BacktraceParser.new(create_multifile_stack).summary
+    assert_equal("toad.rb:8;frog.rb:11", location)
+  end
+
+  def create_duplicate_stack
+    retval = []
+    retval << "/Users/somebody/tinker/dtest/blee.rb:30:in `/'"
+    retval << "/Users/somebody/tinker/dtest/blee.rb:30:in `test_silly_error'"
+    retval << "/Users/somebody/dohtest/lib/doh/test/group_runner.rb:28:in `block in run_group'"
+    retval
+  end
+
+  def test_duplicate_stack
+    location = DohTest::BacktraceParser.new(create_duplicate_stack).summary
+    assert_equal("blee.rb:30", location)
+  end
+
+  def create_block_stack
+    retval = []
+    retval << "/Users/somebody/tinker/dtest/kblah.rb:3:in `block in <class:TestKblah>'"
+    retval
+  end
+
+  def test_block_stack
+    location = DohTest::BacktraceParser.new(create_block_stack).summary
+    assert_equal("kblah.rb:3", location)
+  end
+end
+
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: dohtest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Makani Mason
+- Kem Mason
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-27 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dohutil
+  requirement: &70176037590840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70176037590840
+description: This is a fairly straight forward replacement for minitest, though some
+  changes to test code are required. Code is meant to be easy to understand and extend.
+  Includes dohtest to make execution convenient. Designed for speed, including running
+  tests concurrently (though as of this version that's not implemented).
+email:
+- gitauthor@pqmland.com
+executables:
+- dohtest
+extensions: []
+extra_rdoc_files:
+- MIT-LICENSE
+files:
+- bin/dohtest
+- lib/doh/test/assertions.rb
+- lib/doh/test/backtrace_parser.rb
+- lib/doh/test/configure.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
+- MIT-LICENSE
+homepage: https://github.com/pquimo/dohtest
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Minimalist unit test framework.
+test_files:
+- test/test_backtrace_parser.rb