rubytest 0.5.4 → 0.6.0

data/lib/rubytest/rake.rb

@@ -1,17 +1,19 @@
+require 'rubytest'
 require 'rake/tasklib'
 
-module Ruth
+module Test
 
+  ##
+  # Rake subspace.
   #
   module Rake
 
-    # TODO: The test task uses #fork. Maybe it should shell out instead?
-    #  Or provide the option for either?
-
+    ##
     # Define a test rake task.
     #
     # The `TEST` environment variable can be used to select tests
-    # when using the task.
+    # when using this task. Note, this is just a more convenient
+    # way than using `RUBYTEST_FILES`.
     #
     class TestTask < ::Rake::TaskLib
 
@@ -23,77 +25,67 @@ module Ruth
         'test/**/*_test.rb'
       ]
 
-      # Test scripts to load. Can be a file glob.
-      attr_accessor :tests
-
-      # Paths to add to $LOAD_PATH.
-      attr_accessor :loadpath
-
-      # Scripts to load prior to loading tests.
-      attr_accessor :requires
-
-      # Report format to use.
-      attr_accessor :format
-
-      # Filter tests based by tags.
-      attr_accessor :tags
-
-      # Filter tests by matching description.
-      attr_accessor :match
-
-      # From Rake's own TestTask.
-      alias_method :libs, :loadpath
-      alias_method :test_files, :tests
+      # Test run configuration.
+      #
+      # @return [Config]
+      attr :config
 
+      # Initialize new Rake::TestTask instance.
       #
-      def initialize(name='test', desc="run tests", &block)
-        @name       = name
-        @desc       = desc
+      def initialize(name='test', desc='run tests', &block)
+        @name = name || 'test'
+        @desc = desc
+
+        @config = Test::Config.new
 
-        @loadpath   = ['lib']
-        @requires   = []
-        @tests      = [ENV['TEST'] || DEFAULT_TESTS].flatten
-        @format     = nil
-        @match      = nil
-        @tags       = []
+        @config.files << default_tests if @config.files.empty?
+        @config.loadpath << 'lib' if @config.loadpath.empty?
 
-        block.call(self)
+        block.call(@config)
 
         define_task
       end
 
+      # Define rake task for testing.
       #
+      # @return nothing
       def define_task
         desc @desc
         task @name do
-          @tests ||= default_tests
-          run
+          config.mode == 'shell' ? run_shell : run
         end
       end
 
+      # Run tests, via fork is possible, otherwise straight out.
       #
+      # @return nothing
       def run
-        fork {
-          #require 'test'
-          require 'test/runner'
-
-          loadpath.each   { |d| $LOAD_PATH.unshift(d) }
-          requires.each   { |f| require f }
-          test_files.each { |f| require f }
-
-          suite   = $TEST_SUITE || []
-          runner  = new(suite, :format=>format, :tags=>tags, :match=>match)
+        if Process.respond_to?(:fork)
+          fork {
+            runner  = Test::Runner.new(config)
+            success = runner.run
+            exit -1 unless success
+          }
+          Process.wait
+        else
+          runner  = Test::Runner.new(config)
           success = runner.run
-
           exit -1 unless success
-        }
-        Process.wait
+        end
+      end
+
+      # Run test via command line shell.
+      #
+      # @return nothing
+      def shell_run
+        success = ruby(*config.to_shellwords)
+        exit -1 unless success
       end
 
       # Resolve test globs.
-      #--
-      # TODO: simplify?
-      #++
+      #
+      # @todo Implementation probably cna be simplified.
+      # @return [Array<String>] List of test files.
       def test_files
         files = tests
         files = files.map{ |f| Dir[f] }.flatten
@@ -103,19 +95,40 @@ module Ruth
         files
       end
 
+      # Default test globs. For extra convenience will look for list in
+      # `ENV['TEST']` first.
       #
+      # @return [Array<String>]
       def default_tests
-        if ENV['tests']
-          ENV['tests'].split(/[:;]/)
+        if ENV['TEST']
+          ENV['TEST'].split(/[:;]/)
         else
           DEFAULT_TESTS
         end
       end
 
+=begin
+      # Shell out to current ruby command.
       #
-      #def ruby_command
-      #  File.join(RbConfig::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-      #end
+      # @return [Boolean] Success of shell call.
+      def ruby(*argv)
+        system(ruby_command, *argv)
+      end
+
+      # Get current ruby shell command.
+      #
+      # @return [String] Ruby shell command.
+      def ruby_command
+        @ruby_command ||= (
+          require 'rbconfig'
+          ENV['RUBY'] ||
+            File.join(
+              RbConfig::CONFIG['bindir'],
+              RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']
+            ).sub(/.*\s.*/m, '"\&"')
+        )
+      end
+=end
 
     end
 

data/lib/rubytest/runner.rb

@@ -1,136 +1,58 @@
 module Test
 
+  # Currently this is an alias for configure, however it is likely
+  # to become an alias for `Runner.run` in the future.
+  #
+  # @deprecated Will probably change behavior in future.
+  def self.run(config=nil, &config_proc)
+    $stderr.puts "configuration profiles no longer supported." if config
+    configure(&config_proc)
+  end
+
   # The Test::Runner class handles the execution of tests.
   #
   class Runner
 
-    # Default report is in the old "dot-progress" format.
-    DEFAULT_FORMAT = 'dotprogress'
+    # TODO: Wrap run in at_exit ?
+    def self.run(config=nil, &config_proc)
+      runner = Runner.new(config, &config_proc)
+      begin
+        success = runner.run
+        exit -1 unless success
+      rescue => error
+        raise error if $DEBUG
+        $stderr.puts('ERROR: ' + error.to_s)
+        exit -1
+      end
+    end
 
     # Exceptions that are not caught by test runner.
     OPEN_ERRORS = [NoMemoryError, SignalException, Interrupt, SystemExit]
 
-    # / / / D E F A U L T S / / /
-
-    # Default test suite ($TEST_SUITE).
-    def self.suite
-      $TEST_SUITE
-    end
-
-    # Default list of test files to load.
-    def self.files
-      @files ||= []
-    end
-
-    #
-    def self.format
-      @format || DEFAULT_FORMAT
-    end
-
-    #
-    def self.format=(format)
-      @format = format
-    end
-
-    #
-    def self.verbose
-      @verbose
-    end
-
-    #
-    def self.verbose=(boolean)
-      @verbose = !!boolean
-    end
-
-    # Default description match for filtering tests.
-    def self.match
-      @match ||= []
-    end
-
-    # Default selection of tags for filtering tests.
-    def self.tags
-      @tags ||= []
-    end
+    # Handle all configuration via the config instance.
+    attr :config
 
-    # Default selection of units for filtering tests.
-    def self.units
-      @unit ||= []
-    end
-
-    #
-    def self.hard
-      @hard
+    # Test suite to run. This is a list of compliant test units and test cases.
+    def suite
+      config.suite
     end
 
     #
-    def self.hard=(boolean)
-      @hard = !!boolean
-    end
-
+    # TODO: Cache or not?
     #
-    def self.autopath
-      @autopath
+    def test_files
+      #@test_files ||= resolve_test_files
+      resolve_test_files
     end
 
-    #
-    def self.autopath=(boolean)
-      @autopath = !!boolean
-    end
-
-    # / / / A T T R I B U T E S / / /
-
-    # Test suite to run. This is a list of compliant test units and test cases.
-    attr :suite
-
-    # Test files to load.
-    attr :files
-
     # Reporter format name, or name fragment, used to look up reporter class.
-    attr :format
-
-    #
-    def format=(name)
-      @format = name.to_s
+    def format
+      config.format
     end
 
-    # Matching text used to filter which tests are run.
-    attr :match
-
-    # Selected tags used to filter which tests are run.
-    attr :tags
-
-    # List of units with which to filter tests. It is an array of strings
-    # which are matched against module, class and method names.
-    attr :units
-
     # Show extra details in reports.
     def verbose?
-      @verbose
-    end
-
-    #
-    def verbose=(boolean)
-      @verbose = !!boolean
-    end
-
-    # Use "hard" test mode?
-    def hard?
-      @hard
-    end
-
-    #
-    def hard=(boolean)
-      @hard = !!boolean
-    end
-
-    # Automatically assume local loadpaths?
-    def autopath?
-      @autopath
-    end
-
-    #
-    def autopath=(boolean)
-      @autopath = !!boolean
+      config.verbose?
     end
 
     # Instance of Advice is a special customizable observer.
@@ -158,23 +80,19 @@ module Test
 
     # New Runner.
     #
-    # @param [Array] suite
-    #   A list of compliant tests/testcases.
+    # @param [Config] config
+    #   Config instance.
     #
-    def initialize(options={}, &block)
-      @suite     = options[:suite]    || self.class.suite
-      @files     = options[:files]    || self.class.files
-      @format    = options[:format]   || self.class.format
-      @tags      = options[:tags]     || self.class.tags
-      @units     = options[:units]    || self.class.units
-      @match     = options[:match]    || self.class.match
-      @verbose   = options[:verbose]  || self.class.verbose
-      @hard      = options[:hard]     || self.class.hard
-      @autopath  = options[:autopath] || self.class.autopath
-
-      @advice    = Advice.new
-
-      block.call(self) if block
+    def initialize(config=nil, &block)
+      if config
+        @config = Hash === config ? Config.new(config) : config
+      else
+        @config = Test.configuration
+      end
+
+      block.call(@config) if block
+
+      @advice = Advice.new
     end
 
     # The reporter to use for ouput.
@@ -193,22 +111,27 @@ module Test
     #   That the tests ran without error or failure.
     #
     def run
-      ignore_callers
+      cd_chdir do
+        Test::Config.load_path_setup if config.autopath?
 
-      files_resolved.each do |file|
-        require file
-      end
+        ignore_callers
 
-      @reporter  = reporter_load(format)
-      @recorder  = Recorder.new
+        config.loadpath.each{ |path| $LOAD_PATH.unshift(path) }
+        config.requires.each{ |file| require file }
 
-      @observers = [advice, @recorder, @reporter]
+        test_files.each do |test_file|
+          require test_file
+        end
+
+        @reporter  = reporter_load(format)
+        @recorder  = Recorder.new
+
+        @observers = [advice, @recorder, @reporter]
 
-      #cd_tmp do
         observers.each{ |o| o.begin_suite(suite) }
         run_thru(suite)
         observers.each{ |o| o.end_suite(suite) }
-      #end
+      end
 
       recorder.success?
     end
@@ -273,7 +196,7 @@ module Test
       observers.each{ |o| o.begin_test(test) }
       begin
         success = test.call
-        if hard? && !success  # TODO: separate run_test method to speed things up?
+        if config.hard? && !success  # TODO: separate run_test method to speed things up?
           raise Assertion, "failure of #{test}"
         else
           observers.each{ |o| o.pass(test) }
@@ -312,17 +235,17 @@ module Test
       else
         cases.each do |tc|
           next if tc.respond_to?(:skip?) && tc.skip?
-          next if !match.empty? && !match.any?{ |m| m =~ tc.to_s }
+          next if !config.match.empty? && !config.match.any?{ |m| m =~ tc.to_s }
 
-          if !units.empty?
+          if !config.units.empty?
             next unless tc.respond_to?(:unit)
-            next unless units.find{ |u| tc.unit.start_with?(u) }
+            next unless config.units.find{ |u| tc.unit.start_with?(u) }
           end
 
-          if !tags.empty?
+          if !config.tags.empty?
             next unless tc.respond_to?(:tags)
             tc_tags = [tc.tags].flatten.map{ |t| t.to_s }
-            next if (tags & tc_tags).empty?
+            next if (config.tags & tc_tags).empty?
           end
 
           selected << tc
@@ -335,7 +258,6 @@ module Test
     #
     # @return [Reporter::Abstract]
     #   The test reporter instance.
-    #
     def reporter_load(format)
       format = DEFAULT_REPORT_FORMAT unless format
       format = format.to_s.downcase
@@ -357,7 +279,6 @@ module Test
     #
     # @return [Array<String>]
     #   The names of available reporters.
-    #
     def reporter_list
       list = Dir[File.dirname(__FILE__) + '/reporters/*.rb']
       list = list.map{ |r| File.basename(r).chomp('.rb') }
@@ -368,8 +289,9 @@ module Test
     # Files can be globs and directories which need to be
     # resolved to a list of files.
     #
-    def files_resolved
-      list = files.flatten
+    # @return [Array<String>]
+    def resolve_test_files
+      list = config.files.flatten
       list = list.map{ |f| Dir[f] }.flatten
       list = list.map{ |f| File.directory?(f) ? Dir[File.join(f, '**/*.rb')] : f }
       list = list.flatten.uniq
@@ -377,21 +299,20 @@ module Test
       list
     end
 
-=begin
-  # TODO ?
-  def cd_tmp(&block)
-    dir = Test::Config.root + '/tmp'
-    if Directory.exist?(dir)
-      dir = File.join(dir, 'test')
-      FileUtils.mkdir(dir) unless File.exist?(dir)
-    else
-      dir = File.join(Dir.tmpdir)
+    # Change to directory and run block.
+    #
+    # @raise [Errno::ENOENT] If directory does not exist.
+    def cd_chdir(&block)
+      if dir = config.chdir
+        unless File.directory?(dir)
+          raise Errno::ENOENT, "change directory doesn't exist -- `#{dir}'"
+        end
+        Dir.chdir(dir, &block)
+      else
+        block.call
+      end
     end
 
-    Dir.chdir(dir, &block)
-  end
-=end
-
   end
 
 end