assert 2.15.0 → 2.15.1

data/test/unit/context/suite_dsl_tests.rb

@@ -32,7 +32,7 @@ module Assert::Context::SuiteDSL
       @context_class = Factory.context_class(@parent_class)
     end
 
-    should "default to it's parents subject block" do
+    should "default to it's parent's suite" do
       assert_equal @custom_suite, subject.suite
     end
 

data/test/unit/context_info_tests.rb

@@ -0,0 +1,55 @@
+require 'assert'
+require 'assert/context_info'
+
+require 'assert/context'
+
+class Assert::ContextInfo
+
+  class UnitTests < Assert::Context
+    desc "Assert::ContextInfo"
+    setup do
+      @caller = caller
+      @klass  = Assert::Context
+      @info   = Assert::ContextInfo.new(@klass, nil, @caller.first)
+    end
+    subject{ @info }
+
+    should have_readers :called_from, :klass, :file
+    should have_imeths :test_name
+
+    should "set its klass on init" do
+      assert_equal @klass, subject.klass
+    end
+
+    should "set its called_from to the called_from or first caller on init" do
+      info = Assert::ContextInfo.new(@klass, @caller.first, nil)
+      assert_equal @caller.first, info.called_from
+
+      info = Assert::ContextInfo.new(@klass, nil, @caller.first)
+      assert_equal @caller.first, info.called_from
+    end
+
+    should "set its file from caller info on init" do
+      assert_equal @caller.first.gsub(/\:[0-9]+.*$/, ''), subject.file
+    end
+
+    should "not have any file info if no caller is given" do
+      info = Assert::ContextInfo.new(@klass)
+      assert_nil info.file
+    end
+
+    should "know how to build the contextual test name for a given name" do
+      desc = Factory.string
+      name = Factory.string
+
+      assert_equal name, subject.test_name(name)
+      assert_equal '',   subject.test_name('')
+      assert_equal '',   subject.test_name(nil)
+
+      Assert.stub(subject.klass, :description){ desc }
+      assert_equal "#{desc} #{name}", subject.test_name(name)
+    end
+
+  end
+
+end

data/test/unit/default_runner_tests.rb

@@ -0,0 +1,18 @@
+require 'assert'
+require 'assert/default_runner'
+
+require 'assert/runner'
+
+class Assert::DefaultRunner
+
+  class UnitTests < Assert::Context
+    desc "Assert::DefaultRunner"
+    setup do
+      @config = Factory.modes_off_config
+      @runner = Assert::DefaultRunner.new(@config)
+    end
+    subject{ @runner }
+
+  end
+
+end

data/test/unit/default_suite_tests.rb

@@ -0,0 +1,74 @@
+require 'assert'
+require 'assert/default_suite'
+
+require 'assert/suite'
+
+class Assert::DefaultSuite
+
+  class UnitTests < Assert::Context
+    desc "Assert::DefaultSuite"
+    setup do
+      @config = Factory.modes_off_config
+      @suite  = Assert::DefaultSuite.new(@config)
+
+      ci = Factory.context_info(Factory.modes_off_context_class)
+      [ Factory.test("should nothing", ci){ },
+        Factory.test("should pass",    ci){ assert(1==1); refute(1==0) },
+        Factory.test("should fail",    ci){ ignore; assert(1==0); refute(1==1) },
+        Factory.test("should ignored", ci){ ignore },
+        Factory.test("should skip",    ci){ skip; ignore; assert(1==1) },
+        Factory.test("should error",   ci){ raise Exception; ignore; assert(1==1) }
+      ].each{ |test| @suite.tests << test }
+      @suite.tests.each(&:run)
+    end
+    subject{ @suite }
+
+    should "be a Suite" do
+      assert_kind_of Assert::Suite, subject
+    end
+
+    should "know its test and result attrs" do
+      assert_equal 6, subject.tests.size
+      assert_kind_of Assert::Test, subject.tests.first
+
+      assert_equal subject.tests.size, subject.test_count
+      assert_equal subject.tests,      subject.ordered_tests
+
+      exp = subject.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
+      assert_equal exp, subject.ordered_tests_by_run_time
+
+      assert_equal 8, subject.result_count
+
+      exp = subject.ordered_tests.inject([]){ |results, t| results += t.results }
+      assert_equal exp, subject.ordered_results
+
+      assert_equal 2, subject.result_count(:pass)
+      assert_equal 2, subject.result_count(:fail)
+      assert_equal 2, subject.result_count(:ignore)
+      assert_equal 1, subject.result_count(:skip)
+      assert_equal 1, subject.result_count(:error)
+    end
+
+    should "count its tests and results" do
+      assert_equal subject.test_count,   subject.count(:tests)
+      assert_equal subject.result_count, subject.count(:results)
+
+      assert_equal subject.result_count(:pass), subject.count(:passed)
+      assert_equal subject.result_count(:pass), subject.count(:pass)
+
+      assert_equal subject.result_count(:fail), subject.count(:failed)
+      assert_equal subject.result_count(:fail), subject.count(:fail)
+
+      assert_equal subject.result_count(:ignore), subject.count(:ignored)
+      assert_equal subject.result_count(:ignore), subject.count(:ignore)
+
+      assert_equal subject.result_count(:skip), subject.count(:skipped)
+      assert_equal subject.result_count(:skip), subject.count(:skip)
+
+      assert_equal subject.result_count(:error), subject.count(:errored)
+      assert_equal subject.result_count(:error), subject.count(:error)
+    end
+
+  end
+
+end

data/test/unit/file_line_tests.rb

@@ -23,8 +23,12 @@ class Assert::FileLine
 
     should "handle parsing bad data gracefully" do
       file_line = subject.parse(@file)
-      assert_equal '', file_line.file
-      assert_equal '', file_line.line
+      assert_equal @file, file_line.file
+      assert_equal '',    file_line.line
+
+      file_line = subject.parse(@line)
+      assert_equal @line, file_line.file
+      assert_equal '',    file_line.line
 
       file_line = subject.parse('')
       assert_equal '', file_line.file

data/test/unit/result_tests.rb

@@ -26,7 +26,7 @@ module Assert::Result
     end
 
     should "create results from data hashes" do
-      type   = Assert::Result.types.keys.choice
+      type   = Assert::Result.types.keys.sample
       exp    = Assert::Result.types[type].new(:type => type)
 
       assert_equal exp, Assert::Result.new(:type => type)
@@ -41,7 +41,9 @@ module Assert::Result
         :type      => Factory.string,
         :name      => Factory.string,
         :test_name => Factory.string,
+        :test_id   => Factory.string,
         :message   => Factory.string,
+        :output    => Factory.text,
         :backtrace => Backtrace.new(caller),
         :trace     => Factory.string
       }
@@ -50,7 +52,8 @@ module Assert::Result
     subject{ @result }
 
     should have_cmeths :type, :name, :for_test
-    should have_imeths :type, :name, :test_name, :message, :backtrace, :trace
+    should have_imeths :type, :name, :test_name, :test_id
+    should have_imeths :message, :output, :backtrace, :trace
     should have_imeths *Assert::Result.types.keys.map{ |k| "#{k}?" }
     should have_imeths :set_backtrace, :data, :to_sym, :to_s
 
@@ -67,7 +70,9 @@ module Assert::Result
       exp_backtrace = Backtrace.new(bt)
       exp_trace     = exp_backtrace.filtered.first.to_s
 
-      assert_equal @test.name,    result.test_name
+      assert_equal @test.name,           result.test_name
+      assert_equal @test.file_line.to_s, result.test_id
+
       assert_equal message,       result.message
       assert_equal exp_backtrace, result.backtrace
       assert_equal exp_trace,     result.trace
@@ -77,7 +82,9 @@ module Assert::Result
       assert_equal @given_data[:type].to_sym, subject.type
       assert_equal @given_data[:name],        subject.name
       assert_equal @given_data[:test_name],   subject.test_name
+      assert_equal @given_data[:test_id],     subject.test_id
       assert_equal @given_data[:message],     subject.message
+      assert_equal @given_data[:output],      subject.output
       assert_equal @given_data[:backtrace],   subject.backtrace
       assert_equal @given_data[:trace],       subject.trace
     end
@@ -88,7 +95,9 @@ module Assert::Result
       assert_equal :unknown,          result.type
       assert_equal '',                result.name
       assert_equal '',                result.test_name
+      assert_equal '',                result.test_id
       assert_equal '',                result.message
+      assert_equal '',                result.output
       assert_equal Backtrace.new([]), result.backtrace
       assert_equal '',                result.trace
     end
@@ -117,7 +126,9 @@ module Assert::Result
         :type      => subject.type,
         :name      => subject.name,
         :test_name => subject.test_name,
+        :test_id   => subject.test_id,
         :message   => subject.message,
+        :output    => subject.output,
         :backtrace => subject.backtrace,
         :trace     => subject.trace,
       }
@@ -148,7 +159,7 @@ module Assert::Result
       other = Assert::Result::Base.new(@given_data)
       assert_equal other, subject
 
-      Assert.stub(other, [:type, :message].choice){ Factory.string }
+      Assert.stub(other, [:type, :message].sample){ Factory.string }
       assert_not_equal other, subject
     end
 

data/test/unit/runner_tests.rb

@@ -3,7 +3,8 @@ require 'assert/runner'
 
 require 'stringio'
 require 'assert/config_helpers'
-require 'assert/suite'
+require 'assert/default_suite'
+require 'assert/result'
 require 'assert/view'
 
 class Assert::Runner
@@ -22,22 +23,143 @@ class Assert::Runner
     desc "when init"
     setup do
       @config = Factory.modes_off_config
-      @config.suite Assert::Suite.new(@config)
-      @config.view  Assert::View::Base.new(@config, StringIO.new("", "w+"))
+      @config.suite Assert::DefaultSuite.new(@config)
+      @config.view  Assert::View.new(@config, StringIO.new("", "w+"))
 
       @runner = Assert::Runner.new(@config)
     end
-    subject { @runner }
+    subject{ @runner }
 
     should have_readers :config
-    should have_imeths :run
+    should have_imeths :runner, :run
+    should have_imeths :before_load, :after_load
+    should have_imeths :on_start, :on_finish, :on_interrupt
+    should have_imeths :before_test, :after_test, :on_result
 
     should "know its config" do
       assert_equal @config, subject.config
     end
 
+    should "override the config helper's runner value with itself" do
+      assert_equal subject, subject.runner
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      callback_mixin = Module.new
+      @runner_class = Class.new(Assert::Runner) do
+        include CallbackMixin
+
+        def run!(&block)
+          self.suite.tests.each(&block)
+        end
+      end
+      suite_class  = Class.new(Assert::DefaultSuite){ include CallbackMixin }
+      view_class   = Class.new(Assert::View){ include CallbackMixin }
+
+      @view_output = ""
+
+      @config.suite suite_class.new(@config)
+      @config.view  view_class.new(@config, StringIO.new(@view_output, "w+"))
+
+      @ci = Factory.context_info(Factory.modes_off_context_class)
+      @test = Factory.test("should pass", @ci){ assert(1==1) }
+      @config.suite.tests << @test
+
+      @runner = @runner_class.new(@config)
+      @result = @runner.run
+    end
+
     should "return an integer exit code" do
-      assert_equal 0, subject.run
+      assert_equal 0, @result
+    end
+
+    should "run all callbacks on itself, the suite and the view" do
+      # itself
+      assert_true subject.on_start_called
+      assert_equal [@test], subject.before_test_called
+      assert_instance_of Assert::Result::Pass, subject.on_result_called.last
+      assert_equal [@test], subject.after_test_called
+      assert_true subject.on_finish_called
+
+      # suite
+      suite = @config.suite
+      assert_true suite.on_start_called
+      assert_equal [@test], suite.before_test_called
+      assert_instance_of Assert::Result::Pass, suite.on_result_called.last
+      assert_equal [@test], suite.after_test_called
+      assert_true suite.on_finish_called
+
+      # view
+      view = @config.view
+      assert_true view.on_start_called
+      assert_equal [@test], view.before_test_called
+      assert_instance_of Assert::Result::Pass, view.on_result_called.last
+      assert_equal [@test], view.after_test_called
+      assert_true view.on_finish_called
+    end
+
+    should "descibe running the tests in random order if there are tests" do
+      exp = "Running tests in random order, " \
+            "seeded with \"#{subject.runner_seed}\"\n"
+      assert_includes exp, @view_output
+
+      @view_output.gsub!(/./, '')
+      @config.suite.tests.clear
+      subject.run
+      assert_not_includes exp, @view_output
+    end
+
+    should "run only a single test if a single test is configured" do
+      other_test = Factory.test("should also pass", @ci){ assert(1==1) }
+      @config.suite.tests << other_test
+
+      @config.single_test @test.file_line.to_s
+
+      runner = @runner_class.new(@config)
+      runner.run
+      assert_equal [@test], runner.before_test_called
+    end
+
+    should "descibe running only a single test if a single test is configured" do
+      @config.single_test @test.file_line.to_s
+      @view_output.gsub!(/./, '')
+      subject.run
+
+      exp = "Running test: #{subject.single_test_file_line}\n"
+      assert_includes exp, @view_output
+    end
+
+  end
+
+  module CallbackMixin
+    attr_reader :on_start_called, :on_finish_called
+    attr_reader :before_test_called, :after_test_called, :on_result_called
+
+    def on_start
+      @on_start_called = true
+    end
+
+    def before_test(test)
+      @before_test_called ||= []
+      @before_test_called << test
+    end
+
+    def on_result(result)
+      @on_result_called ||= []
+      @on_result_called << result
+    end
+
+    def after_test(test)
+      @after_test_called ||= []
+      @after_test_called << test
+    end
+
+    def on_finish
+      @on_finish_called = true
     end
 
   end

data/test/unit/suite_tests.rb

@@ -1,5 +1,7 @@
 require 'assert'
 require 'assert/suite'
+
+require 'assert/config_helpers'
 require 'assert/test'
 require 'test/support/inherited_stuff'
 
@@ -7,217 +9,106 @@ class Assert::Suite
 
   class UnitTests < Assert::Context
     desc "Assert::Suite"
-    setup do
-      @config = Factory.modes_off_config
-      @suite = Assert::Suite.new(@config)
-    end
-    subject{ @suite }
+    subject{ Assert::Suite }
 
-    should have_accessors :config, :tests, :test_methods, :start_time, :end_time
-    should have_imeths :ordered_tests, :ordered_tests_by_run_time
-    should have_imeths :results, :ordered_results
-    should have_imeths :run_time, :test_rate, :result_rate
-    should have_imeths :count, :test_count, :result_count
-    should have_imeths :setup, :startup, :teardown, :shutdown
-
-    should "determine a klass' local public test methods" do
-      exp = ["test_subclass_stuff", "test_mixin_stuff", "test_repeated"].sort
-      act = subject.send(:local_public_test_methods, SubStuff).sort.map(&:to_s)
-      assert_equal(exp, act)
+    should "include the config helpers" do
+      assert_includes Assert::ConfigHelpers, subject
     end
 
-    should "have a zero run time, test rate and result rate by default" do
-      assert_equal 0, subject.run_time
-      assert_equal 0, subject.test_rate
-      assert_equal 0, subject.result_rate
+    should "know its test method regex" do
+      assert_match     "test#{Factory.string}", subject::TEST_METHOD_REGEX
+      assert_not_match "#{Factory.string}test", subject::TEST_METHOD_REGEX
     end
 
   end
 
-  class WithTestsTests < UnitTests
-    desc "a suite with tests"
+  class InitTests < Assert::Context
+    desc "when init"
     setup do
-      ci = Factory.context_info(Factory.modes_off_context_class)
-      @suite.tests = [
-        Factory.test("should nothing", ci){ },
-        Factory.test("should pass",    ci){ assert(1==1); refute(1==0) },
-        Factory.test("should fail",    ci){ ignore; assert(1==0); refute(1==1) },
-        Factory.test("should ignored", ci){ ignore },
-        Factory.test("should skip",    ci){ skip; ignore; assert(1==1) },
-        Factory.test("should error",   ci){ raise Exception; ignore; assert(1==1) }
-      ]
-      @suite.tests.each(&:run)
-    end
-
-    should "build test instances to run" do
-      assert_kind_of Assert::Test, subject.tests.first
-    end
-
-    should "know how many tests it has" do
-      assert_equal 6, subject.test_count
-    end
-
-    should "know its ordered tests" do
-      assert_equal subject.tests, subject.ordered_tests
-    end
-
-    should "know its tests ordered by run time" do
-      exp = subject.ordered_tests.sort{ |a, b| a.run_time <=> b.run_time }
-      assert_equal exp, subject.ordered_tests_by_run_time
-    end
-
-    should "know how many results it has" do
-      assert_equal 8, subject.result_count
-    end
-
-    should "know its ordered results" do
-      assert_equal subject.results, subject.ordered_results
-    end
-
-    should "know how many pass results it has" do
-      assert_equal 2, subject.result_count(:pass)
-    end
-
-    should "know how many fail results it has" do
-      assert_equal 2, subject.result_count(:fail)
-    end
-
-    should "know how many ignore results it has" do
-      assert_equal 2, subject.result_count(:ignore)
-    end
-
-    should "know how many skip results it has" do
-      assert_equal 1, subject.result_count(:skip)
-    end
-
-    should "know how many error results it has" do
-      assert_equal 1, subject.result_count(:error)
-    end
-
-    should "count its tests" do
-      assert_equal subject.test_count, subject.count(:tests)
-    end
-
-    should "count its results" do
-      assert_equal subject.result_count, subject.count(:results)
-    end
-
-    should "count its passed results" do
-      assert_equal subject.result_count(:pass), subject.count(:passed)
-      assert_equal subject.result_count(:pass), subject.count(:pass)
-    end
-
-    should "count its failed results" do
-      assert_equal subject.result_count(:fail), subject.count(:failed)
-      assert_equal subject.result_count(:fail), subject.count(:fail)
-    end
-
-    should "count its ignored results" do
-      assert_equal subject.result_count(:ignore), subject.count(:ignored)
-      assert_equal subject.result_count(:ignore), subject.count(:ignore)
-    end
-
-    should "count its skipped results" do
-      assert_equal subject.result_count(:skip), subject.count(:skipped)
-      assert_equal subject.result_count(:skip), subject.count(:skip)
-    end
-
-    should "count its errored results" do
-      assert_equal subject.result_count(:error), subject.count(:errored)
-      assert_equal subject.result_count(:error), subject.count(:error)
-    end
-
-  end
-
-  class SetupTests < UnitTests
-    desc "a suite with a setup block"
-    setup do
-      @setup_status = nil
-      @setup_blocks = []
-      @setup_blocks << ::Proc.new{ @setup_status = "setup" }
-      @setup_blocks << ::Proc.new{ @setup_status += " has been run" }
-      @setup_blocks.each{ |setup_block| @suite.setup(&setup_block) }
+      @config = Factory.modes_off_config
+      @suite  = Assert::Suite.new(@config)
     end
+    subject{ @suite }
 
-    should "set the setup status to the correct message" do
-      subject.setup
-      assert_equal "setup has been run", @setup_status
-    end
+    should have_readers :config, :tests, :test_methods
+    should have_accessors :start_time, :end_time
+    should have_imeths :suite, :setup, :startup, :teardown, :shutdown
+    should have_imeths :run_time, :test_rate, :result_rate, :count
+    should have_imeths :ordered_tests, :reversed_tests
+    should have_imeths :ordered_tests_by_run_time, :reversed_tests_by_run_time
+    should have_imeths :test_count
+    should have_imeths :ordered_results, :reversed_results
+    should have_imeths :ordered_results_for_dump, :reversed_results_for_dump
+    should have_imeths :result_count
+    should have_imeths :before_load, :after_load
+    should have_imeths :on_start, :on_finish, :on_interrupt
+    should have_imeths :before_test, :after_test, :on_result
 
-    should "return the setup blocks with the #setups method" do
-      @setup_blocks.each do |setup_block|
-        assert_includes setup_block, subject.send(:setups)
-      end
+    should "know its config" do
+      assert_equal @config, subject.config
     end
 
-  end
-
-  class TeardownTests < UnitTests
-    desc "a suite with a teardown"
-    setup do
-      @teardown_status = nil
-      @teardown_blocks = []
-      @teardown_blocks << ::Proc.new{ @teardown_status += " has been run" }
-      @teardown_blocks << ::Proc.new{ @teardown_status = "teardown" }
-      @teardown_blocks.each{ |teardown_block| @suite.teardown(&teardown_block) }
+    should "override the config helper's suite value with itself" do
+      assert_equal subject, subject.suite
     end
 
-    should "set the teardown status to the correct message" do
-      subject.teardown
-      assert_equal "teardown has been run", @teardown_status
-    end
+    should "default its attrs" do
+      assert_equal [], subject.tests
+      assert_equal [], subject.test_methods
+      assert_equal [], subject.setups
+      assert_equal [], subject.teardowns
 
-    should "return the teardown blocks with the #teardowns method" do
-      @teardown_blocks.each do |setup_block|
-        assert_includes setup_block, subject.send(:teardowns)
-      end
+      assert_equal subject.start_time, subject.end_time
     end
 
-  end
-
-  class ContextInfoTests < UnitTests
-    desc "ContextInfo"
-    setup do
-      @caller = caller
-      @klass  = Assert::Context
-      @info   = Assert::Suite::ContextInfo.new(@klass, nil, @caller.first)
-    end
-    subject{ @info }
+    should "know its run time and rates" do
+      assert_equal 0, subject.run_time
+      assert_equal 0, subject.test_rate
+      assert_equal 0, subject.result_rate
 
-    should have_readers :called_from, :klass, :file
-    should have_imeths :test_name
+      time = Factory.integer(3).to_f
+      subject.end_time = subject.start_time + time
+      count = Factory.integer(10)
+      Assert.stub(subject, :test_count){ count }
+      Assert.stub(subject, :result_count){ count }
 
-    should "set its klass on init" do
-      assert_equal @klass, subject.klass
+      assert_equal time, subject.run_time
+      assert_equal (subject.test_count / subject.run_time),   subject.test_rate
+      assert_equal (subject.result_count / subject.run_time), subject.result_rate
     end
 
-    should "set its called_from to the called_from or first caller on init" do
-      info = Assert::Suite::ContextInfo.new(@klass, @caller.first, nil)
-      assert_equal @caller.first, info.called_from
+    should "not provide any test or result attrs" do
+      assert_nil subject.ordered_tests
+      assert_nil subject.reversed_tests
+      assert_nil subject.ordered_tests_by_run_time
+      assert_nil subject.reversed_tests_by_run_time
+      assert_nil subject.test_count
 
-      info = Assert::Suite::ContextInfo.new(@klass, nil, @caller.first)
-      assert_equal @caller.first, info.called_from
+      assert_nil subject.ordered_results
+      assert_nil subject.reversed_results
+      assert_nil subject.ordered_results_for_dump
+      assert_nil subject.reversed_results_for_dump
+      assert_nil subject.result_count
     end
 
-    should "set its file from caller info on init" do
-      assert_equal @caller.first.gsub(/\:[0-9]+.*$/, ''), subject.file
-    end
+    should "add setup procs" do
+      status = nil
+      @suite.setup{ status = "setups" }
+      @suite.startup{ status += " have been run" }
 
-    should "not have any file info if no caller is given" do
-      info = Assert::Suite::ContextInfo.new(@klass)
-      assert_nil info.file
+      assert_equal 2, subject.setups.count
+      subject.setups.each(&:call)
+      assert_equal "setups have been run", status
     end
 
-    should "know how to build the contextual test name for a given name" do
-      desc = Factory.string
-      name = Factory.string
-
-      assert_equal name, subject.test_name(name)
-      assert_equal '',   subject.test_name('')
-      assert_equal '',   subject.test_name(nil)
+    should "add teardown procs" do
+      status = nil
+      @suite.teardown{ status = "teardowns" }
+      @suite.shutdown{ status += " have been run" }
 
-      Assert.stub(subject.klass, :description){ desc }
-      assert_equal "#{desc} #{name}", subject.test_name(name)
+      assert_equal 2, subject.teardowns.count
+      subject.teardowns.each(&:call)
+      assert_equal "teardowns have been run", status
     end
 
   end