assert 0.6.0 → 0.7.0

data/lib/assert/rake_tasks/irb.rb

@@ -0,0 +1,33 @@
+module Assert::RakeTasks
+  class Irb
+
+    def self.file_name
+      "irb.rb"
+    end
+
+    def self.task_name
+      :irb
+    end
+
+    def initialize(test_root)
+      @test_root = test_root
+    end
+
+    def file_path
+      File.join(@test_root.to_s, self.class.file_name)
+    end
+
+    def helper_exists?
+      File.exists?(self.file_path)
+    end
+
+    def description
+      "Open irb preloaded with #{self.file_path}"
+    end
+
+    def cmd
+      "irb -rubygems -r ./#{self.file_path}"
+    end
+
+  end
+end

data/lib/assert/rake_tasks/scope.rb

@@ -0,0 +1,73 @@
+require 'rake/tasklib'
+require 'assert/rake_tasks/test_task'
+
+module Assert::RakeTasks
+  class Scope
+
+    def self.test_file_suffix
+      "_test.rb"
+    end
+
+    def initialize(path)
+      @path = path
+    end
+
+    def namespace
+      File.basename(@path).to_sym
+    end
+
+    # nested test files under the path
+    def nested_files
+      nested_files = Rake::FileList["#{@path}/**/*#{self.class.test_file_suffix}"]
+    end
+
+    # a list with the path test file "#{path}_test.rb" (if it exists)
+    def path_file_list
+      path_file_name = @path+self.class.test_file_suffix
+      (File.exists?(path_file_name) ? Rake::FileList[path_file_name] : [])
+    end
+
+    # return a test task covering the scopes nested files plus path file
+    # but only if there are nested files
+    def to_test_task
+      if !self.nested_files.empty?
+        TestTask.new(@path) do |tt|
+          tt.files = self.path_file_list + self.nested_files
+        end
+      end
+    end
+
+    # a collection of test tasks for every standalone child test file
+    def test_tasks
+      # get immediate child test files
+      Dir.glob("#{@path}/*#{self.class.test_file_suffix}").collect do |f|
+        # get just the path name for each file
+        File.join(File.dirname(f), File.basename(f, self.class.test_file_suffix))
+      end.reject do |p|
+        # reject any that have deeply nested test files
+        !Dir.glob("#{p}/**/*#{self.class.test_file_suffix}").empty?
+      end.collect do |p|
+        # build a test task for the standalone test file of the path
+        TestTask.new(p) do |tt|
+          tt.files = Rake::FileList[p+self.class.test_file_suffix]
+        end
+      end
+    end
+
+    # a collection of scopes for every child test dir or test dir/file combo
+    def scopes
+      # get immediate child paths
+      Dir.glob("#{@path}/*").collect do |p|
+        # get just the path name for each dir/file and uniq it
+        File.join(File.dirname(p), File.basename(p, self.class.test_file_suffix))
+      end.uniq.select do |p|
+        # select any that have deeply nested test files
+        !Dir.glob("#{p}/**/*#{self.class.test_file_suffix}").empty?
+      end.collect do |p|
+        # build a scope for each path
+        self.class.new(p)
+      end
+    end
+
+  end
+end

data/lib/assert/rake_tasks/test_task.rb

@@ -0,0 +1,63 @@
+require 'assert/rake_tasks/scope'
+
+module Assert::RakeTasks
+
+  class TestTask
+
+    attr_accessor :name, :path, :files
+
+    # Create a testing task
+    def initialize(path)
+      @path = path
+      @files = []
+      yield self if block_given?
+    end
+
+    def relative_path
+      File.join(@path.to_s.split(File::SEPARATOR)[1..-1])
+    end
+
+    def scope_description
+      relative_path.empty? ? "" : " for #{relative_path}"
+    end
+
+    def description
+      "Run all tests#{scope_description}"
+    end
+
+    def name
+      File.basename(@path, Scope.test_file_suffix).to_sym
+    end
+
+    def file_list # :nodoc:
+      self.files.collect{|f| "\"#{f}\""}.join(' ')
+    end
+
+    def ruby_args
+      [ "-rrubygems",
+        "\"#{self.rake_loader}\"",
+        self.file_list
+      ].compact.join(" ")
+    end
+
+    def show_loaded_files?
+      ENV["show_loaded_files"] == 'true'
+    end
+
+    protected
+
+    def rake_loader
+      find_file('rake/rake_test_loader')
+    end
+
+    def find_file(fn) # :nodoc:
+      $LOAD_PATH.each do |path|
+        file_path = File.join(path, "#{fn}.rb")
+        return file_path if File.exist? file_path
+      end
+      nil
+    end
+
+  end
+
+end

data/lib/assert/result.rb

@@ -3,11 +3,10 @@ module Assert::Result
 
   class Base; end
   class Pass < Base; end
-  class Fail < Base; end
   class Ignore < Base; end
-  class FromException < Base; end
-  class Error < FromException; end
-  class Skip < FromException; end
+  class Fail < Base; end
+  class Error < Base; end
+  class Skip < Base; end
 
   class << self
     def types
@@ -39,7 +38,6 @@ module Assert::Result
 
     # './lib' in project dir, or '/usr/local/blahblah' if installed
     ASSERT_DIR = File.dirname(File.dirname(file))
-    MACROS_DIR = File.join(File.dirname(file), 'macros')
 
     def initialize(value=nil)
       super(value || ["No backtrace"])
@@ -66,7 +64,7 @@ module Assert::Result
     protected
 
     def filter_out?(line)
-      line.rindex(ASSERT_DIR, 0) && !line.rindex(MACROS_DIR, 0)
+      line.rindex(ASSERT_DIR, 0)
     end
 
   end
@@ -76,11 +74,11 @@ module Assert::Result
 
   class Base
 
-    attr_reader :test_name, :message, :backtrace
+    attr_reader :test, :message, :backtrace
 
-    def initialize(test_name, message, backtrace=nil)
+    def initialize(test, message, backtrace=nil)
+      @test = test
       @backtrace = Backtrace.new(backtrace)
-      @test_name = test_name
       @message = message && !message.empty? ? message : nil
     end
 
@@ -88,10 +86,21 @@ module Assert::Result
       define_method("#{meth}?") { false }
     end
 
+    def test_name
+      @test.name
+    end
+
     def to_sym; nil; end
 
     def to_s
-      [self.test_name, self.message, self.trace].compact.join("\n")
+      [ "#{self.name.upcase}: #{self.test_name}",
+        self.message,
+        self.trace
+      ].compact.join("\n")
+    end
+
+    def name
+      ""
     end
 
     def trace
@@ -109,58 +118,97 @@ module Assert::Result
   end
 
   class Pass < Base
+
     def pass?; true; end
-    def to_sym; :passed; end
+    def to_sym; :pass; end
 
-    def to_s
-      "PASS: #{super}"
+    def name
+      "Pass"
     end
-  end
-
-  class Fail < Base
-    def fail?; true; end
-    def to_sym; :failed; end
 
-    def to_s
-      "FAIL: #{super}"
-    end
   end
 
   class Ignore < Base
+
     def ignore?; true; end
-    def to_sym; :ignored; end
+    def to_sym; :ignore; end
 
-    def to_s
-      "IGNORE: #{super}"
+    def name
+      "Ignore"
     end
+
   end
 
-  # Error and Skip results are built from exceptions being raised
-  class FromException < Base
-    def initialize(test_name, exception)
-      super(test_name, exception.message, exception.backtrace || [])
+  # raised by the 'fail' context helper to break test execution
+  # (if Test.halt_on_fail?)
+  class TestFailure < RuntimeError; end
+
+  class Fail < Base
+
+    # fail results can be generated manually or by raising Assert::Result::TestFailure
+    def initialize(test, message_or_exception, backtrace=nil)
+      if message_or_exception.kind_of?(TestFailure)
+        super(test, message_or_exception.message, message_or_exception.backtrace || [])
+      elsif message_or_exception.kind_of?(Exception)
+        raise ArgumentError, "generate fail results by raising Assert::Result::TestFailure"
+      else
+        super(test, message_or_exception, backtrace)
+      end
+    end
+
+    def fail?; true; end
+    def to_sym; :fail; end
+
+    def name
+      "Fail"
     end
+
+    # override of the base, show the test's context info called_from
+    def trace
+      self.test.context_info.called_from
+    end
+
   end
 
   # raised by the 'skip' context helper to break test execution
   class TestSkipped < RuntimeError; end
 
-  class Skip < FromException
+  class Skip < Base
+
+    # skip results are generated by raising Assert::Result::TestSkipped
+    def initialize(test, exception)
+      if exception.kind_of?(TestSkipped)
+        super(test, exception.message, exception.backtrace || [])
+      else
+        raise ArgumentError, "generate skip results by raising Assert::Result::TestSkipped"
+      end
+    end
+
     def skip?; true; end
-    def to_sym; :skipped; end
+    def to_sym; :skip; end
 
-    def to_s
-      "SKIP: #{super}"
+    def name
+      "Skip"
     end
+
   end
 
-  class Error < FromException
+  class Error < Base
+
+    # error results are generated by raising exceptions in tests
+    def initialize(test, exception)
+      if exception.kind_of?(Exception)
+        super(test, "#{exception.message} (#{exception.class.name})", exception.backtrace || [])
+      else
+        raise ArgumentError, "generate error results by raising an exception"
+      end
+    end
 
     def error?; true; end
-    def to_sym; :errored; end
+    def to_sym; :error; end
 
-    def to_s
-      "ERROR: #{super}"
+    def name
+      "Error"
     end
 
     # override of the base, always show the full unfiltered backtrace for errors

data/lib/assert/setup/helpers.rb

@@ -11,7 +11,7 @@ module Assert
     class << self
 
       USER_TEST_HELPER = "~/.assert/options"
-      
+
       # assume the test dir path is ./test and look for helpers in ./test/helper.rb
       def package_test_dir
         "test"
@@ -34,7 +34,9 @@ module Assert
 
       def require_user_test_helper
         begin
-          require File.expand_path(USER_TEST_HELPER)
+          if ENV['HOME']
+            require File.expand_path(USER_TEST_HELPER)
+          end
         rescue LoadError => err
           # do nothing
         end
@@ -45,7 +47,7 @@ module Assert
         begin
           require package_helper_file(root_path)
         rescue LoadError => err
-          warn err.message
+          # do nothing
         end
       end
 
@@ -57,7 +59,8 @@ module Assert
       # this expects the caller's root path to be the parent dir of the first
       # parent dir of caller named TEST_DIR
       def caller_root_path(caller_info)
-        caller_dirname = File.expand_path(File.dirname(caller_info[0]))
+        non_custom_require_caller_info = caller_info.reject{|i| i =~ /rubygems\/custom_require.rb/}
+        caller_dirname = File.expand_path(File.dirname(non_custom_require_caller_info[0]))
         test_dir_pos = caller_dirname.index(package_test_helper_regex)
         if test_dir_pos && (test_dir_pos > 0)
           caller_dirname[0..(test_dir_pos-1)]

data/lib/assert/suite.rb

@@ -1,15 +1,38 @@
 require 'assert/test'
 
 module Assert
-  class Suite < ::Hash
+  class Suite
+
+    class ContextInfo
+
+      attr_reader :klass, :called_from, :file
+
+      def initialize(klass, called_from=nil)
+        @klass = klass
+        @called_from = called_from
+        @file = if called_from
+          called_from.gsub(/\:[0-9]+.*$/, '')
+        end
+      end
+
+    end
+
+    TEST_METHOD_REGEX = /^test./
 
     # A suite is a set of tests to run.  When a test class subclasses
     # the Context class, that test class is pushed to the suite.
 
-    attr_accessor :start_time, :end_time
+    attr_accessor :tests, :test_methods, :start_time, :end_time
+
+    def initialize
+      @tests = []
+      @test_methods = []
+      @start_time = 0
+      @end_time = 0
+    end
 
     def run_time
-      (@end_time || 0) - (@start_time || 0)
+      @end_time - @start_time
     end
 
     def runner_seed
@@ -19,42 +42,12 @@ module Assert
       end).to_i
     end
 
-    def <<(context_klass)
-      # gsub off any trailing 'Test'
-      self[context_klass] ||= []
-    end
-
-    def contexts
-      self.keys.sort{|a,b| a.to_s <=> b.to_s}
-    end
-
-    def tests
-      prep
-      self.values.flatten
-    end
-
-    def ordered_tests(klass=nil)
-      prep
-      (klass.nil? ? self.contexts : [klass]).inject([]) do |tests, klass|
-        tests += (self[klass] || [])
-      end
-    end
-
-    def ordered_results(klass=nil)
-      ordered_tests(klass).inject([]) do |results, test|
-        results += test.results
-      end
-    end
+    alias_method :ordered_tests, :tests
 
-    def test_count(klass=nil)
-      prep
-      count_tests(klass.nil? ? self.values : [self[klass]])
-    end
-
-    def result_count(type=nil)
-      prep
-      count_results(self.values, type)
+    def results
+      tests.inject([]) {|results, test| results += test.results}
     end
+    alias_method :ordered_results, :results
 
     def count(thing)
       case thing
@@ -77,6 +70,20 @@ module Assert
       end
     end
 
+    def test_count
+      self.tests.size
+    end
+
+    def result_count(type=nil)
+      if type
+        self.tests.inject(0) do |count, test|
+          count += test.result_count(type)
+        end
+      else
+        self.results.size
+      end
+    end
+
     def setup(&block)
       if block_given?
         self.setups << block
@@ -119,30 +126,7 @@ module Assert
       methods += local_methods
 
       # uniq and remove any that don't start with 'test'
-      methods.uniq.delete_if {|method_name| method_name !~ /^test./ }
-    end
-
-    private
-
-    def count_tests(test_sets)
-      test_sets.inject(0) {|count, tests| count += tests.size}
-    end
-
-    def count_results(test_sets, type)
-      self.values.flatten.inject(0){|count, test| count += test.result_count(type) }
-    end
-
-    def prep
-      if @prepared != true
-        # look for local public methods starting with 'test_'and add
-        self.each do |context_class, tests|
-          local_public_test_methods(context_class).each do |meth|
-            tests << Test.new(meth.to_s, context_class, meth)
-          end
-          tests.uniq
-        end
-      end
-      @prepared = true
+      methods.uniq.delete_if {|method_name| method_name !~ TEST_METHOD_REGEX }
     end
 
   end