assert 2.4.0 → 2.5.0

data/test/unit/context/suite_dsl_tests.rb

@@ -0,0 +1,47 @@
+require 'assert'
+require 'assert/context/suite_dsl'
+
+require 'assert/suite'
+
+module Assert::Context::SuiteDSL
+
+  class UnitTests < Assert::Context
+    desc "Assert::Context::SuiteDSL"
+    setup do
+      @custom_suite = Factory.modes_off_suite
+      @context_class = Factory.context_class
+    end
+    subject{ @context_class }
+
+    should "use `Assert.suite` by default" do
+      assert_equal Assert.suite, subject.suite
+    end
+
+    should "use any given custom suite" do
+      subject.suite(@custom_suite)
+      assert_equal @custom_suite, subject.suite
+    end
+
+  end
+
+  class SuiteFromParentTests < UnitTests
+    desc "`suite` method using parent context"
+    setup do
+      @parent_class = Factory.context_class
+      @parent_class.suite(@custom_suite)
+      @context_class = Factory.context_class(@parent_class)
+    end
+
+    should "default to it's parents subject block" do
+      assert_equal @custom_suite, subject.suite
+    end
+
+    should "use any given custom suite" do
+      another_suite = Factory.modes_off_suite
+      subject.suite(another_suite)
+      assert_equal another_suite, subject.suite
+    end
+
+  end
+
+end

data/test/unit/context/{test_should_singleton_tests.rb → test_dsl_tests.rb}

@@ -1,25 +1,23 @@
 require 'assert'
-require 'assert/context'
+require 'assert/context/test_dsl'
 
-class Assert::Context
+module Assert::Context::TestDSL
 
-  # `ContextSingletonTests` defined in `test/helper.rb`
-  class TestShouldSingletonTests < ContextSingletonTests
-    desc "test and should methods"
+  class UnitTests < Assert::Context
+    desc "Assert::Context::TestDSL"
     setup do
-      @test_count_before = Assert.suite.tests.size
       @test_desc = "be true"
       @test_block = ::Proc.new{ assert(true) }
     end
 
     should "build a test using `test` with a desc and code block" do
       d, b = @test_desc, @test_block
-      Factory.context_class { test(d, &b) }
+      context_class = Factory.modes_off_context_class{ test(d, &b) }
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context_class.suite.tests.size
 
       exp_test_name = @test_desc
-      built_test = Assert.suite.tests.last
+      built_test = context_class.suite.tests.first
       assert_kind_of Assert::Test, built_test
       assert_equal exp_test_name, built_test.name
       assert_equal @test_block, built_test.code
@@ -27,12 +25,12 @@ class Assert::Context
 
     should "build a test using `should` with a desc and code block" do
       d, b = @test_desc, @test_block
-      Factory.context_class { should(d, &b) }
+      context_class = Factory.modes_off_context_class{ should(d, &b) }
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context_class.suite.tests.size
 
       exp_test_name = "should #{@test_desc}"
-      built_test = Assert.suite.tests.last
+      built_test = context_class.suite.tests.last
       assert_kind_of Assert::Test, built_test
       assert_equal exp_test_name, built_test.name
       assert_equal @test_block, built_test.code
@@ -42,10 +40,10 @@ class Assert::Context
       d, b = @test_desc, @test_block
       context = build_eval_context{ test_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_equal "", err.message
     end
 
@@ -53,10 +51,10 @@ class Assert::Context
       d, b = @test_desc, @test_block
       context = build_eval_context{ should_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_equal "", err.message
     end
 
@@ -64,10 +62,10 @@ class Assert::Context
       d = @test_desc
       context = build_eval_context { test(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_equal "TODO", err.message
     end
 
@@ -75,10 +73,10 @@ class Assert::Context
       d = @test_desc
       context = build_eval_context { should(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_equal "TODO", err.message
     end
 
@@ -86,10 +84,10 @@ class Assert::Context
       d = @test_desc
       context = build_eval_context{ test_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_equal "TODO", err.message
     end
 
@@ -97,27 +95,27 @@ class Assert::Context
       d = @test_desc
       context = build_eval_context{ should_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_equal "TODO", err.message
     end
 
     should "build a test from a macro using `test`" do
       d, b = @test_desc, @test_block
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
-      Factory.context_class { test(m) }
+      context_class = Factory.modes_off_context_class{ test(m) }
 
-      assert_equal @test_count_before+2, Assert.suite.tests.size
+      assert_equal 2, context_class.suite.tests.size
     end
 
     should "build a test from a macro using `should`" do
       d, b = @test_desc, @test_block
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
-      Factory.context_class { should(m) }
+      context_class = Factory.modes_off_context_class{ should(m) }
 
-      assert_equal @test_count_before+2, Assert.suite.tests.size
+      assert_equal 2, context_class.suite.tests.size
     end
 
     should "build a test that skips from a macro using `test_eventually`" do
@@ -125,9 +123,9 @@ class Assert::Context
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
       context = build_eval_context{ test_eventually(m) }
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_raises(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
     end
 
@@ -136,9 +134,9 @@ class Assert::Context
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
       context = build_eval_context{ should_eventually(m) }
 
-      assert_equal @test_count_before+1, Assert.suite.tests.size
+      assert_equal 1, context.class.suite.tests.size
       assert_raises(Assert::Result::TestSkipped) do
-        context.instance_eval(&Assert.suite.tests.last.code)
+        context.instance_eval(&context.class.suite.tests.last.code)
       end
 
     end
@@ -146,9 +144,10 @@ class Assert::Context
     private
 
     def build_eval_context(&build_block)
-      context_class = Factory.context_class &build_block
+      context_class = Factory.modes_off_context_class &build_block
       context_info  = Factory.context_info(context_class)
-      context_class.new(Factory.test("whatever", context_info))
+      test = Factory.test("whatever", context_info)
+      context_class.new(test, test.config)
     end
 
     def capture_err(err_class, &block)

data/test/unit/context_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'assert/context'
 
+require 'assert/config'
 require 'assert/utils'
 
 class Assert::Context
@@ -10,13 +11,19 @@ class Assert::Context
     setup do
       @test = Factory.test
       @context_class = @test.context_class
-      @context = @context_class.new(@test)
-    end
-    teardown do
-      TEST_ASSERT_SUITE.tests.clear
+      @context = @context_class.new(@test, @test.config)
     end
     subject{ @context }
 
+    # DSL methods
+    should have_cmeths :description, :desc, :describe, :subject, :suite
+    should have_cmeths :setup_once, :before_once, :startup
+    should have_cmeths :teardown_once, :after_once, :shutdown
+    should have_cmeths :setup, :before, :setups
+    should have_cmeths :teardown, :after, :teardowns
+    should have_cmeths :test, :test_eventually, :test_skip
+    should have_cmeths :should, :should_eventually, :should_skip
+
     should have_imeths :assert, :assert_not, :refute
     should have_imeths :skip, :pass, :fail, :flunk, :ignore
     should have_imeths :with_backtrace, :subject
@@ -115,16 +122,13 @@ class Assert::Context
   class HaltOnFailTests < FailTests
     desc "when halting on fails"
     setup do
-      @orig_halt_fail = Assert.config.halt_on_fail
+      @halt_config = Assert::Config.new(:halt_on_fail => true)
+      @context = @context_class.new(@test, @halt_config)
       @fail_msg = "something failed"
     end
-    teardown do
-      Assert.config.halt_on_fail @orig_halt_fail
-    end
     subject{ @result }
 
     should "raise an exception with the failure's message" do
-      Assert.config.halt_on_fail true
       err = begin
         @context.fail @fail_msg
       rescue Exception => exception
@@ -158,10 +162,10 @@ class Assert::Context
     end
 
     should "pp the assertion value in the fail message by default" do
-      exp_default_what = "Failed assert: assertion was `#{Assert::U.show(false)}`."
+      exp_def_what = "Failed assert: assertion was `#{Assert::U.show(false, @test.config)}`."
       result = subject.assert(false, @fail_desc)
 
-      assert_equal [@fail_desc, exp_default_what].join("\n"), result.message
+      assert_equal [@fail_desc, exp_def_what].join("\n"), result.message
     end
 
     should "use a custom fail message if one is given" do
@@ -197,10 +201,10 @@ class Assert::Context
     end
 
     should "pp the assertion value in the fail message by default" do
-      exp_default_what = "Failed assert_not: assertion was `#{Assert::U.show(true)}`."
+      exp_def_what = "Failed assert_not: assertion was `#{Assert::U.show(true, @test.config)}`."
       result = subject.assert_not(true, @fail_desc)
 
-      assert_equal [@fail_desc, exp_default_what].join("\n"), result.message
+      assert_equal [@fail_desc, exp_def_what].join("\n"), result.message
     end
 
     should "return a fail result given a \"truthy\" assertion" do
@@ -217,10 +221,10 @@ class Assert::Context
     desc "subject method"
     setup do
       expected = @expected = "amazing"
-      @context_class = Factory.context_class do
+      @context_class = Factory.modes_off_context_class do
         subject{ @something = expected }
       end
-      @context = @context_class.new
+      @context = @context_class.new(@test, @test.config)
       @subject = @context.subject
     end
     subject{ @subject }

data/test/unit/runner_tests.rb

@@ -8,13 +8,19 @@ class Assert::Runner
   class BasicTests < Assert::Context
     desc "a basic runner"
     setup do
-      @suite  = Assert::Suite.new
+      @config = Factory.modes_off_config
+      @suite  = Assert::Suite.new(@config)
       @view   = Assert::View::Base.new(StringIO.new("", "w+"), @suite)
-      @runner = Assert::Runner.new
+      @runner = Assert::Runner.new(@config)
     end
     subject { @runner }
 
-    should have_instance_methods :run
+    should have_readers :config
+    should have_imeths :run
+
+    should "know its config" do
+      assert_equal @config, subject.config
+    end
 
     should "return an integer exit code" do
       assert_equal 0, subject.run(@suite, @view)

data/test/unit/suite_tests.rb

@@ -5,17 +5,19 @@ require 'test/support/inherited_stuff'
 
 class Assert::Suite
 
-  class BasicTests < Assert::Context
-    desc "an basic suite"
+  class UnitTests < Assert::Context
+    desc "Assert::Suite"
     setup do
-      @suite = Assert::Suite.new
+      @config = Factory.modes_off_config
+      @suite = Assert::Suite.new(@config)
     end
     subject{ @suite }
 
-    should have_imeths :ordered_tests, :results, :ordered_results, :run_time
+    should have_accessors :config, :tests, :test_methods, :start_time, :end_time
+    should have_imeths :ordered_tests, :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 have_accessors :tests, :test_methods, :start_time, :end_time
 
     should "determine a klass' local public test methods" do
       exp = ["test_subclass_stuff", "test_mixin_stuff", "test_repeated"].sort
@@ -23,17 +25,18 @@ class Assert::Suite
       assert_equal(exp, act)
     end
 
-    should "have zero a run time by default" do
+    should "have a zero run time, test rate and result by default" do
       assert_equal 0, subject.run_time
+      assert_equal 0, subject.test_rate
+      assert_equal 0, subject.result_rate
     end
 
   end
 
-  class WithTestsTests < Assert::Context
+  class WithTestsTests < UnitTests
     desc "a suite with tests"
     setup do
-      ci = Factory.context_info(Factory.context_class)
-      @suite = Assert::Suite.new
+      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) },
@@ -44,7 +47,6 @@ class Assert::Suite
       ]
       @suite.tests.each(&:run)
     end
-    subject{ @suite }
 
     should "build test instances to run" do
       assert_kind_of Assert::Test, subject.tests.first
@@ -121,37 +123,33 @@ class Assert::Suite
 
   end
 
-  class SetupTests < Assert::Context
+  class SetupTests < UnitTests
     desc "a suite with a setup block"
     setup do
       @setup_status = nil
-      @suite = Assert::Suite.new
       @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) }
     end
-    subject{ @setup_status }
 
     should "set the setup status to the correct message" do
-      @suite.setup
-      assert_equal "setup has been run", subject
+      subject.setup
+      assert_equal "setup has been run", @setup_status
     end
 
     should "return the setup blocks with the #setups method" do
-      setups = @suite.send(:setups)
       @setup_blocks.each do |setup_block|
-        assert_includes setup_block, setups
+        assert_includes setup_block, subject.send(:setups)
       end
     end
 
   end
 
-  class TeardownTests < Assert::Context
+  class TeardownTests < UnitTests
     desc "a suite with a teardown"
     setup do
       @teardown_status = nil
-      @suite = Assert::Suite.new
       @teardown_blocks = []
       @teardown_blocks << ::Proc.new{ @teardown_status += " has been run" }
       @teardown_blocks << ::Proc.new{ @teardown_status = "teardown" }
@@ -159,20 +157,19 @@ class Assert::Suite
     end
 
     should "set the teardown status to the correct message" do
-      @suite.teardown
+      subject.teardown
       assert_equal "teardown has been run", @teardown_status
     end
 
     should "return the teardown blocks with the #teardowns method" do
-      teardowns = @suite.send(:teardowns)
       @teardown_blocks.each do |setup_block|
-        assert_includes setup_block, teardowns
+        assert_includes setup_block, subject.send(:teardowns)
       end
     end
 
   end
 
-  class ContextInfoTests < Assert::Context
+  class ContextInfoTests < UnitTests
     desc "a suite's context info"
     setup do
       @caller = caller