assert 0.6.0 → 0.7.0

data/CHANGELOG.rdoc

@@ -0,0 +1,21 @@
+== Assert Changes
+
+=== v0.7.0
+* tests know context info (klass, called_from, file) (#62)
+* suites track tests ungrouped
+* fixed issue where method macros display incorrect fail traces
+* fixed bug where 'assert_raises' and 'assert_nothing_raised' generate fail messages with trailing newlines
+* default halt on failed assertions (#68)
+* fixed for setup error when no $HOME env var (#76)
+* changelog tracking (#79)
+* removed past tense from Result model #to_sym (#75)
+* showing exception class in Error result message (#64)
+* don't show verbose loading statement when running rake tasks (#72)
+* forced loading rubygems when running rake tasks (#65)
+* removed warning if no test/helper present (#66)
+* fix to not load helpers twice (#67)
+* overhaul to how the rake tasks are generated and handled (#69)
+* added name attr to Result model (#61)
+
+=== v0.6.0
+* everything prior to changelog tracking...

data/Gemfile.lock

@@ -1,18 +1,18 @@
 PATH
   remote: .
   specs:
-    assert (0.6.0)
-      assert-view (~> 0.3)
+    assert (0.7.0)
+      assert-view (~> 0.4)
 
 GEM
   remote: http://rubygems.org/
   specs:
     ansi (1.3.0)
-    assert-view (0.3.0)
+    assert-view (0.4.0)
       ansi (~> 1.3)
       undies (~> 1.1)
     rake (0.9.2)
-    undies (1.1.0)
+    undies (1.2.0)
 
 PLATFORMS
   ruby

data/README.rdoc

@@ -65,13 +65,18 @@ Result defines the data related to a test result.  There are a few kinds of test
 * Skip
 * Ignore
 
-Tests can have many results of varying types.
+Tests produce results as they are executed.  Every assert statement produces a result.  Some results, like Error and Skip, will halt execution.  Pass and Ignore results do not halt execution.  Fail results, by default, halt execution but there is an option to have them not halt execution.  Therefore, tests can have many results of varying types.
 
 === Macro
 Macros are procs that define sets of test code and make it available for easy reuse.  Macros work nicely with the 'should' and 'test' context methods.
 
 
 
+== User Options and Helpers
+Assert provides ways for setting user-specfic options and helpers.  When Assert is setting itself up, the last setup step is to look for and require the file ~/.assert/options.rb.  This file is essentially a user level test helper file.  Use it to set options, configure assert extensions, setup or define how to view test results, etc.
+
+
+
 == Running Tests
 Assert uses a Runner object to run tests.  Any runner object should take the test suite and view as arguments and should provide a 'run' method that runs the tests and renders the view.
 
@@ -84,6 +89,14 @@ The default Runner object runs tests in random order and the default Terminal vi
     $ rake test   # run tests in random order
     $ rake test runner_seed=1234  # run tests seeding with '1234'
 
+=== Failure Handling
+Assert, by default, will halt test execution when a test produces a Fail result.  However, Assert provides an option to not halt when Fail results are produced.  You can control how assert handles fails by either setting an option (in your user .assert/options.rb file) or by setting an env variable:
+
+    Assert::Test.options.halt_on_fail false   # force not halting on fail results
+
+    $ rake test halt_on_fail=true             # force halt on failure using an env var
+
+
 === Rake Tasks
 Assert provides some rake task helpers that will scan your test folder and recursively generate rake tasks for each one of your test folders or files ending in '_test'.  Use this as an alternative to running ruby on each one of your test files individually.
 
@@ -110,6 +123,10 @@ This would generate following rake tasks:
     rake test:complex:fast            # Run tests for assertions:assert_block
     rake test:complex:slow            # Run tests for assertions:assert_empty
 
+By default, the rake tasks do not show which test files are being loaded.  If you want to see this output from the rake tasks, set a "show_loaded_files" environment variable at the rake command line:
+
+    $ rake test show_loaded_files=true  # run the tests showing which files were loaded
+
 === IRB with your environment loaded
 Assert provides a rake task for running irb with your test environment loaded.  Create an irb.rb file in your test file directory and have it require 'assert/setup'.  See https://github.com/teaminsight/assert/blob/master/test/irb.rb for an example.  Here's how you could use it:
 

data/assert.gemspec

@@ -18,5 +18,5 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency("bundler", ["~> 1.0"])
-  s.add_dependency("assert-view", ["~> 0.3"])
+  s.add_dependency("assert-view", ["~> 0.4"])
 end

data/lib/assert/assertions.rb

@@ -15,14 +15,14 @@ module Assert
 
 
     def assert_raises(*args, &block)
-      assertion, fail_desc = check_exception(args, :raises, &block)
-      assert(assertion, fail_desc, "")
+      assertion, what_failed_msg = check_exception(args, :raises, &block)
+      assert(assertion, nil, what_failed_msg)
     end
     alias_method :assert_raise, :assert_raises
 
     def assert_nothing_raised(*args, &block)
-      assertion, fail_desc = check_exception(args, :not_raises, &block)
-      assert(!assertion, fail_desc, "")
+      assertion, what_failed_msg = check_exception(args, :not_raises, &block)
+      assert(!assertion, nil, what_failed_msg)
     end
     alias_method :assert_not_raises, :assert_nothing_raised
     alias_method :assert_not_raise, :assert_nothing_raised

data/lib/assert/autorun.rb

@@ -1,4 +1,4 @@
-require 'assert/setup'
+require 'assert/setup/all'
 
 module Assert
 

data/lib/assert/context.rb

@@ -14,9 +14,23 @@ module Assert
     # minimal base logic/methods/instance_vars.  The instance should remain
     # pure to not pollute test scopes.
 
-    # if a class subclasses Context, add it to the suite
-    def self.inherited(klass)
-      Assert.suite << klass
+    # if a test method is added to a context manually (not using a context helper):
+    # capture any context info, build a test obj, and add it to the suite
+    def self.method_added(method_name)
+      if method_name.to_s =~ Suite::TEST_METHOD_REGEX
+        called_from = caller.first
+        klass_method_name = "#{self}##{method_name}"
+
+        if Assert.suite.test_methods.include?(klass_method_name)
+          puts "WARNING: redefining '#{klass_method_name}'"
+          puts "  from: #{called_from}"
+        else
+          Assert.suite.test_methods << klass_method_name
+        end
+
+        ci = Suite::ContextInfo.new(self, called_from)
+        Assert.suite.tests << Test.new(method_name.to_s, ci, method_name)
+      end
     end
 
     # put all logic here to keep context instances pure for running tests
@@ -99,7 +113,8 @@ module Assert
         end
       end
 
-      def test(desc_or_macro, &block)
+      def test(desc_or_macro, called_from=nil, &block)
+        called_from ||= caller.first
         if desc_or_macro.kind_of?(Macro)
           instance_eval(&desc_or_macro)
         else
@@ -108,34 +123,27 @@ module Assert
           # if no block given, create a test that just skips
           method_block = block_given? ? block : (Proc.new { skip })
 
-          # instead of using the typical 'method_defined?' pattern (which) checks
-          # all parent contexts, we really just need to make sure the method_name
-          # is not part of self's local_pulic_test_methods for this check
-          if Assert.suite.send(:local_public_test_methods, self).include?(method_name)
-            from = caller.first
-            puts "WARNING: should #{desc_or_macro.inspect} is redefining #{method_name}!"
-            puts "  from: #{from}"
-            puts "  self: #{self.inspect}"
-          end
-
-          define_method(method_name, &method_block)
+          ci = Suite::ContextInfo.new(self, called_from)
+          Assert.suite.tests << Test.new(method_name, ci, &method_block)
         end
       end
 
-      def test_eventually(desc, &block)
-        test(desc)
+      def test_eventually(desc_or_macro, called_from=nil, &block)
+        called_from ||= caller.first
+        test(desc_or_macro, called_from)
       end
       alias_method :test_skip, :test_eventually
 
-      def should(desc_or_macro, &block)
+      def should(desc_or_macro, called_from=nil, &block)
+        called_from ||= caller.first
         if !desc_or_macro.kind_of?(Macro)
           desc_or_macro = "should #{desc_or_macro}"
         end
-        test(desc_or_macro, &block)
+        test(desc_or_macro, called_from, &block)
       end
 
-      def should_eventually(desc, &block)
-        should(desc)
+      def should_eventually(desc_or_macro, called_from=nil, &block)
+        should(desc_or_macro, called_from)
       end
       alias_method :should_skip, :should_eventually
 
@@ -176,35 +184,39 @@ module Assert
     end
     alias_method :refute, :assert_not
 
-    # adds a Skip result to the end of the test's results and breaks test execution
-    def skip(skip_msg=nil)
-      raise(Result::TestSkipped, skip_msg || "")
-    end
-
     # adds a Pass result to the end of the test's results
     # does not break test execution
     def pass(pass_msg=nil)
-      capture_result do |test_name, backtrace|
-        Assert::Result::Pass.new(test_name, pass_msg, backtrace)
+      capture_result do |test, backtrace|
+        Assert::Result::Pass.new(test, pass_msg, backtrace)
+      end
+    end
+
+    # adds an Ignore result to the end of the test's results
+    # does not break test execution
+    def ignore(ignore_msg=nil)
+      capture_result do |test, backtrace|
+        Assert::Result::Ignore.new(test, ignore_msg, backtrace)
       end
     end
 
     # adds a Fail result to the end of the test's results
     # does not break test execution
     def fail(fail_msg=nil)
-      capture_result do |test_name, backtrace|
-        message = (fail_message(fail_msg) { }).call
-        Assert::Result::Fail.new(test_name, message, backtrace)
+      message = (fail_message(fail_msg) { }).call
+      if Assert::Test.halt_on_fail?
+        raise(Result::TestFailure, message)
+      else
+        capture_result do |test, backtrace|
+          Assert::Result::Fail.new(test, message, backtrace)
+        end
       end
     end
     alias_method :flunk, :fail
 
-    # adds an Ignore result to the end of the test's results
-    # does not break test execution
-    def ignore(ignore_msg=nil)
-      capture_result do |test_name, backtrace|
-        Assert::Result::Ignore.new(test_name, ignore_msg, backtrace)
-      end
+    # adds a Skip result to the end of the test's results and breaks test execution
+    def skip(skip_msg=nil)
+      raise(Result::TestSkipped, skip_msg || "")
     end
 
     def subject
@@ -230,7 +242,7 @@ module Assert
 
     def capture_result
       if block_given?
-        result = yield @__running_test__.name, caller
+        result = yield @__running_test__, caller
         @__running_test__.results << result
         result
       end

data/lib/assert/macros/methods.rb

@@ -10,9 +10,10 @@ module Assert::Macros
     module ClassMethods
 
       def have_instance_method(*methods)
+        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller).first
         Assert::Macro.new do
           methods.each do |method|
-            should "respond to instance method ##{method}" do
+            should "respond to instance method ##{method}", called_from do
               assert_respond_to method, subject, "#{subject.class.name} does not have instance method ##{method}"
             end
           end
@@ -21,9 +22,10 @@ module Assert::Macros
       alias_method :have_instance_methods, :have_instance_method
 
       def have_class_method(*methods)
+        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller).first
         Assert::Macro.new do
           methods.each do |method|
-            should "respond to class method ##{method}" do
+            should "respond to class method ##{method}", called_from do
               assert_respond_to method, subject.class, "#{subject.class.name} does not have class method ##{method}"
             end
           end
@@ -32,17 +34,26 @@ module Assert::Macros
       alias_method :have_class_methods, :have_class_method
 
       def have_reader(*methods)
+        unless methods.last.kind_of?(Array)
+          methods << caller
+        end
         have_instance_methods(*methods)
       end
       alias_method :have_readers, :have_reader
 
       def have_writer(*methods)
-        have_instance_methods(*methods.collect{|m| "#{m}="})
+        called = methods.last.kind_of?(Array) ? methods.pop : caller
+        writer_meths = methods.collect{|m| "#{m}="}
+        writer_meths << called
+        have_instance_methods(*writer_meths)
       end
       alias_method :have_writers, :have_writer
 
       def have_accessor(*methods)
-        have_instance_methods(*methods.collect{|m| [m, "#{m}="]}.flatten)
+        called = methods.last.kind_of?(Array) ? methods.pop : caller
+        accessor_meths = methods.collect{|m| [m, "#{m}="]}.flatten
+        accessor_meths << called
+        have_instance_methods(*accessor_meths)
       end
       alias_method :have_accessors, :have_accessor
 

data/lib/assert/rake_tasks.rb

@@ -1,7 +1,12 @@
 require 'rake'
-require 'rake/tasklib'
 
 module Assert; end
+module Assert::RakeTasks; end
+
+require 'assert/rake_tasks/irb'
+require 'assert/rake_tasks/scope'
+require 'assert/rake_tasks/test_task'
+
 module Assert::RakeTasks
 
   FILE_SUFFIX = "_test.rb"
@@ -10,101 +15,52 @@ module Assert::RakeTasks
   # * add 'include Assert::RakeTasks' to your Rakefile
   def self.included(receiver)
     # auto-build rake tasks for the ./test files (if defined in ./test)
-    self.for(:test) if File.exists?(File.expand_path('./test', Dir.pwd))
+    self.for('test') if File.exists?(File.expand_path('./test', Dir.pwd))
   end
 
-  def self.for(test_namespace = :test)
-    self.irb_task(test_namespace.to_s)
-    self.to_tasks(test_namespace.to_s)
-  end
-
-
-
-
-  class TestTask < Rake::TaskLib
-
-    attr_accessor :name, :description, :test_files
-
-    # Create a testing task.
-    def initialize(name=:test)
-      @name = name
-      @description = "Run tests" + (@name==:test ? "" : " for #{@name}")
-      @test_files = []
-      yield self if block_given?
-    end
-
-    # Define the rake task to run this test suite
-    def to_task
-      desc @description
-      task @name do
-        RakeFileUtils.verbose(true) { ruby "\"#{rake_loader}\" " + file_list }
-      end
-    end
-
-    def file_list # :nodoc:
-      @test_files.collect{|f| "\"#{f}\""}.join(' ')
-    end
-
-    protected
-
-    def rake_loader # :nodoc:
-      find_file('rake/rake_test_loader') or
-        fail "unable to find 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
+  def self.for(test_root='test')
+    self.irb_task(Assert::RakeTasks::Irb.new(test_root.to_s))
+    self.to_tasks(Assert::RakeTasks::Scope.new(test_root.to_s))
   end
 
   class << self
     include Rake::DSL if defined? Rake::DSL
 
-    def irb_task(path)
-      irb_file = File.join(path, "irb.rb")
-      if File.exist?(irb_file)
-        desc "Open irb preloaded with #{irb_file}"
-        task :irb do
-          sh "irb -rubygems -r ./#{irb_file}"
+    def irb_task(irb)
+      if irb.helper_exists?
+        desc irb.description
+        task irb.class.task_name do
+          sh irb.cmd
         end
       end
     end
 
-    def to_tasks(path)
-      suite_name = File.basename(path)
-
-      # define a rake test task for all test files that have addional sub-folder tests
-      if !Dir.glob(File.join(path, "**/*#{FILE_SUFFIX}")).empty?
-        TestTask.new(suite_name.to_sym) do |t|
-          file_location = suite_name == path ? '' : " for #{File.join(path.split(File::SEPARATOR)[1..-1])}"
-          t.description = "Run all tests#{file_location}"
-          t.test_files = (File.exists?(p = (path+FILE_SUFFIX)) ? FileList[p] : []) + FileList["#{path}/**/*#{FILE_SUFFIX}"]
-        end.to_task
+    def to_tasks(scope)
+      # if there is a test task for the scope
+      if (scope_tt = scope.to_test_task)
+        # create a rake task to run it
+        desc scope_tt.description
+        task scope_tt.name do
+          RakeFileUtils.verbose(scope_tt.show_loaded_files?) { ruby scope_tt.ruby_args }
+        end
       end
 
-      namespace suite_name.to_s do
-        Dir.glob(File.join(path, "*#{FILE_SUFFIX}")).each do |test_file|
-          test_name = File.basename(test_file, FILE_SUFFIX)
-
-          # define rake test task for all test files without sub-folder tests
-          if Dir.glob(File.join(path, test_name, "*#{FILE_SUFFIX}")).empty?
-            TestTask.new(test_name.to_sym) do |t|
-              t.description = "Run tests for #{[path.split(File::SEPARATOR), test_name].flatten[1..-1].join(':')}"
-              t.test_files = FileList[test_file]
-            end.to_task
+      # create a namespace for the scope
+      namespace scope.namespace do
+        # for each test task in the scope, create a rake task to run it
+        scope.test_tasks.each do |test_file_tt|
+          desc test_file_tt.description
+          task test_file_tt.name do
+            RakeFileUtils.verbose(test_file_tt.show_loaded_files?) { ruby test_file_tt.ruby_args }
           end
         end
 
-        # recursively define rake test tasks for each file
-        # in each top-level directory
-        Dir.glob(File.join(path, "*")).each do |test_dir|
-          self.to_tasks(test_dir)
+        # recusively generate rake tasks for each sub-scope in the scope
+        scope.scopes.each do |sub_scope|
+          self.to_tasks(sub_scope)
         end
       end
+
     end
   end