assert 1.1.0 → 2.0.0.rc.1

data/lib/assert/assert_runner.rb

@@ -0,0 +1,76 @@
+module Assert
+
+  class AssertRunner
+    TEST_FILE_SUFFIXES  = ['_tests.rb', '_test.rb']
+    USER_SETTINGS_FILE  = ".assert/init.rb"
+    LOCAL_SETTINGS_FILE = ".assert.rb"
+
+    def initialize(test_paths, test_options)
+      require 'assert'  # inits config singleton with the default settings
+
+      apply_user_settings
+      apply_local_settings
+      apply_option_settings(test_options)
+      apply_env_settings
+
+      files = test_files(test_paths.empty? ? Assert.config.test_dir : test_paths)
+      Assert.init(files, {
+        :test_dir_path => path_of(Assert.config.test_dir, files.first)
+      })
+    end
+
+    def run
+      Assert.runner.run(Assert.suite, Assert.view)
+    end
+
+    protected
+
+    def apply_user_settings
+      safe_require("#{ENV['HOME']}/#{USER_SETTINGS_FILE}") if ENV['HOME']
+    end
+
+    def apply_local_settings
+      safe_require(ENV['ASSERT_LOCALFILE'] || path_of(LOCAL_SETTINGS_FILE, Dir.pwd))
+    end
+
+    def apply_option_settings(options)
+      Assert.config.apply(options)
+    end
+
+    def apply_env_settings
+      Assert.configure do |c|
+        c.runner_seed ENV['ASSERT_RUNNER_SEED'].to_i if ENV['ASSERT_RUNNER_SEED']
+      end
+    end
+
+    private
+
+    def test_files(test_paths)
+      test_paths.inject(Set.new) do |paths, path|
+        paths += Dir.glob("#{path}*") + Dir.glob("#{path}*/**/*")
+      end.select{ |p| is_test_file?(p) }.sort
+    end
+
+    def is_test_file?(path)
+      TEST_FILE_SUFFIXES.inject(false) do |result, suffix|
+        result || path =~ /#{suffix}$/
+      end
+    end
+
+    def safe_require(settings_file)
+      require settings_file if File.exists?(settings_file)
+    end
+
+    # this method inspects a test path and finds the test dir path.
+
+    def path_of(segment, a_path)
+      full_path = File.expand_path(a_path || '.', Dir.pwd)
+      seg_pos = full_path.index(segment_regex(segment))
+      File.join(seg_pos && (seg_pos > 0) ? full_path[0..(seg_pos-1)] : full_path, segment)
+    end
+
+    def segment_regex(seg); /^#{seg}$|^#{seg}\/|\/#{seg}\/|\/#{seg}$/; end
+
+  end
+
+end

data/lib/assert/cli.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'assert/assert_runner'
 require 'assert/version'
 
 module Assert
@@ -10,75 +11,53 @@ module Assert
     end
 
     def initialize
-      @cli = CLIRB.new
+      @cli = CLIRB.new do
+        option 'runner_seed', 'Use a given seed to run tests', {
+          :abbrev => 's', :value => Fixnum
+        }
+        option 'show_output', 'show stdout output (do not capture)', {
+          :abbrev => 'o'
+        }
+        option 'halt_on_fail', 'halt a test when it fails', {
+          :abbrev => 't'
+        }
+        # show loaded test files, cli err backtraces, etc
+        option 'debug', 'run in debug mode'
+      end
     end
 
     def run(*args)
+      # default debug_mode to the env var
+      debug_mode = ENV['ASSERT_DEBUG'] == 'true'
       begin
-        @cli.parse!(*args)
-        tests = @cli.args
-        tests = ['test'] if tests.empty?
-        Assert::CLIRunner.new(*tests).run
+        # parse manually in the case that parsing fails before the debug arg
+        debug_mode ||= args.include?('-d') || args.include?('--debug')
+        @cli.parse!(args)
+        Assert::AssertRunner.new(@cli.args, @cli.opts).run
       rescue CLIRB::HelpExit
         puts help
       rescue CLIRB::VersionExit
         puts Assert::VERSION
       rescue CLIRB::Error => exception
-        puts "#{exception.message}\n"
-        puts help
+        puts "#{exception.message}\n\n"
+        puts  debug_mode ? exception.backtrace.join("\n") : help
         exit(1)
       rescue Exception => exception
         puts "#{exception.class}: #{exception.message}"
-        puts exception.backtrace.join("\n") if ENV['DEBUG']
+        puts exception.backtrace.join("\n") if debug_mode
         exit(1)
       end
-
-      # Don't call `exit(0)`.  The test suite runs as the by an `at_exit`
-      # callback.  Calling `exit(0)` bypasses that callback.
+      exit(0)
     end
 
     def help
-      "Usage: assert [TESTS] [options]\n\n"\
+      "Usage: assert [options] [TESTS]\n\n"\
       "Options:"\
       "#{@cli}"
     end
 
   end
 
-  class CLIRunner
-    TEST_FILE_SUFFIXES = ['_tests.rb', '_test.rb']
-
-    attr_reader :test_files
-
-    def initialize(*args)
-      options, test_paths = [
-        args.last.kind_of?(::Hash) ? args.pop : {},
-        args
-      ]
-
-      @test_files = file_paths(test_paths).select{ |f| test_file?(f) }
-    end
-
-    def run
-      @test_files.each{ |file| require file }
-      require 'assert' if @test_files.empty?  # show empty test output
-    end
-
-    private
-
-    def file_paths(test_paths)
-      test_paths.inject(Set.new) do |paths, path|
-        paths += Dir.glob("#{path}*") + Dir.glob("#{path}*/**/*")
-      end
-    end
-
-    def test_file?(path)
-      TEST_FILE_SUFFIXES.inject(false) do |result, suffix|
-        result || path =~ /#{suffix}$/
-      end
-    end
-  end
-
   class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
     Error    = Class.new(RuntimeError);
     HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)

data/lib/assert/context.rb

@@ -204,11 +204,11 @@ module Assert
     end
 
     # adds a Fail result to the end of the test's results
-    # does not break test execution
+    # break test execution if Assert.config.halt_on_fail
     def fail(fail_msg=nil)
       message = (fail_message(fail_msg) { }).call
-      if Assert::Test.halt_on_fail?
-        raise(Result::TestFailure, message)
+      if Assert.config.halt_on_fail
+        raise Result::TestFailure, message
       else
         capture_result do |test, backtrace|
           Assert::Result::Fail.new(test, message, backtrace)

data/lib/assert/result.rb

@@ -17,59 +17,6 @@ module Assert::Result
     }
   end
 
-  class Backtrace < ::Array
-    # ripped from minitest...
-
-    file = File.expand_path __FILE__
-           # if RUBY_VERSION =~ /^1\.9/ then  # bt's expanded, but __FILE__ isn't :(
-           #    File.expand_path __FILE__
-           # elsif  __FILE__ =~ /^[^\.]/ then # assume both relative
-           #   require 'pathname'
-           #   pwd = Pathname.new Dir.pwd
-           #   pn = Pathname.new File.expand_path(__FILE__)
-           #   relpath = pn.relative_path_from(pwd) rescue pn
-           #   pn = File.join ".", relpath unless pn.relative?
-           #   pn.to_s
-           # else                             # assume both are expanded
-           #   __FILE__
-           # end
-
-    # './lib' in project dir, or '/usr/local/blahblah' if installed
-    ASSERT_DIR = File.dirname(File.dirname(file))
-
-    def initialize(value=nil)
-      super(value || ["No backtrace"])
-    end
-
-    def to_s
-      self.join("\n")
-    end
-
-    def filtered
-      new_bt = []
-
-      self.each do |line|
-        break if filter_out?(line)
-        new_bt << line
-      end
-
-      new_bt = self.reject { |line| filter_out?(line) } if new_bt.empty?
-      new_bt = self.dup if new_bt.empty?
-
-      self.class.new(new_bt)
-    end
-
-    protected
-
-    def filter_out?(line)
-      line.rindex(ASSERT_DIR, 0)
-    end
-
-  end
-
-
-  # Result classes...
-
   class Base
 
     attr_reader :test, :message, :backtrace
@@ -138,8 +85,7 @@ module Assert::Result
   end
 
   # raised by the 'fail' context helper to break test execution
-  # (if Test.halt_on_fail?)
-  class TestFailure < RuntimeError; end
+  TestFailure = Class.new(RuntimeError)
 
   class Fail < Base
 
@@ -213,6 +159,70 @@ module Assert::Result
     def trace
       self.backtrace.to_s
     end
+
+  end
+
+  # Utility Classes
+
+  class Set < ::Array
+    attr_accessor :callback
+
+    def initialize(callback=nil)
+      @callback = callback
+      super()
+    end
+
+    def <<(result)
+      super
+      @callback.call(result) if @callback
+    end
+  end
+
+  class Backtrace < ::Array
+    def initialize(value=nil)
+      super(value || ["No backtrace"])
+    end
+
+    def to_s; self.join("\n"); end
+
+    def filtered
+      new_bt = []
+
+      self.each do |line|
+        break if filter_out?(line)
+        new_bt << line
+      end
+
+      new_bt = self.reject { |line| filter_out?(line) } if new_bt.empty?
+      new_bt = self.dup if new_bt.empty?
+
+      self.class.new(new_bt)
+    end
+
+    protected
+
+    # filter a line out if it's an assert lib line
+
+    def filter_out?(line)
+      # from minitest (for reference)...
+      # file = File.expand_path __FILE__
+             # if RUBY_VERSION =~ /^1\.9/ then  # bt's expanded, but __FILE__ isn't :(
+             #    File.expand_path __FILE__
+             # elsif  __FILE__ =~ /^[^\.]/ then # assume both relative
+             #   require 'pathname'
+             #   pwd = Pathname.new Dir.pwd
+             #   pn = Pathname.new File.expand_path(__FILE__)
+             #   relpath = pn.relative_path_from(pwd) rescue pn
+             #   pn = File.join ".", relpath unless pn.relative?
+             #   pn.to_s
+             # else                             # assume both are expanded
+             #   __FILE__
+             # end
+
+      # './lib' in project dir, or '/usr/local/blahblah' if installed
+      assert_lib_path = File.expand_path('../..', __FILE__)
+      line.rindex(assert_lib_path, 0)
+    end
   end
 
 end

data/lib/assert/runner.rb

@@ -1,54 +1,35 @@
 module Assert
+
   class Runner
 
-    # a Runner runs a suite of tests.
+    # Runner runs a suite of tests.
 
-    def initialize(suite, view)
+    def run(suite, view)
       raise ArgumentError if !suite.kind_of?(Suite)
-      @suite = suite
-      @view = view
-    end
 
-    def run
-      @view.fire(:on_start)
-      @suite.setup
+      view.fire(:on_start)
+      suite.setup
 
-      benchmark { run_suite }
-
-      @suite.teardown
-      @view.fire(:on_finish)
+      suite.start_time = Time.now
+      # TODO: parallel running
+      tests_to_run(suite).each do |test|
+        view.fire(:before_test, test)
+        test.run{ |result| view.fire(:on_result, result) }
+        view.fire(:after_test, test)
+      end
+      suite.end_time = Time.now
 
-      count(:failed) + count(:errored)
-    end
+      suite.teardown
+      view.fire(:on_finish)
 
-    def count(type)
-      @suite.count(type)
+      suite.count(:failed) + suite.count(:errored)
     end
 
     protected
 
-    def tests_to_run
-      # order tests randomly
-      tests = @suite.tests
-      srand @suite.runner_seed
-      tests.sort.sort_by { rand tests.size }
-    end
-
-    private
-
-    def benchmark
-      @suite.start_time = Time.now
-      yield if block_given?
-      @suite.end_time = Time.now
-    end
-
-    def run_suite
-      # TODO: parallel running
-      tests_to_run.each do |test|
-        @view.fire(:before_test, test)
-        test.run {|result| @view.fire(:on_result, result)}
-        @view.fire(:after_test, test)
-      end
+    def tests_to_run(suite)
+      srand Assert.config.runner_seed # TODO: secure random??
+      suite.tests.sort.sort_by { rand suite.tests.size }
     end
 
   end

data/lib/assert/suite.rb

@@ -36,13 +36,6 @@ module Assert
       @end_time - @start_time
     end
 
-    def runner_seed
-      @run_seed ||= (ENV["runner_seed"] || begin
-        srand
-        srand % 0xFFFF
-      end).to_i
-    end
-
     alias_method :ordered_tests, :tests
 
     def results

data/lib/assert/test.rb

@@ -1,20 +1,8 @@
-require 'assert/result'
-require 'assert/result_set'
-require 'assert/options'
-
 require 'stringio'
+require 'assert/result'
 
 module Assert
   class Test
-    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.
@@ -26,7 +14,7 @@ module Assert
       @context_info = suite_context_info
       @name = name_from_context(name)
       @code = (code || block)
-      @results = ResultSet.new
+      @results = Result::Set.new
       @output = ""
     end
 
@@ -36,7 +24,7 @@ module Assert
 
     def run(&result_callback)
       # setup the a new test run
-      @results = ResultSet.new(result_callback)
+      @results = Result::Set.new(result_callback)
       run_scope = self.context_class.new(self)
 
       # run the test, capturing its output
@@ -118,7 +106,7 @@ module Assert
     end
 
     def capture_output(&block)
-      if self.class.options.capture_output
+      if Assert.config.show_output == false
         orig_stdout = $stdout.clone
         $stdout = capture_io
         block.call