assert 2.0.0.rc.1 → 2.0.0

data/test/{runner_test.rb → unit/runner_tests.rb}

@@ -1,12 +1,11 @@
 require 'assert'
-
 require 'assert/suite'
 require 'assert/view/base'
 require 'assert/runner'
 
 class Assert::Runner
 
-  class BasicTest < Assert::Context
+  class BasicTests < Assert::Context
     desc "a basic runner"
     setup do
       @suite  = Assert::Suite.new

data/test/{suite_test.rb → unit/suite_tests.rb}

@@ -1,76 +1,55 @@
 require 'assert'
-
 require 'assert/suite'
-require 'assert/context'
 require 'assert/test'
-require 'test/fixtures/inherited_stuff'
-require 'test/fixtures/sample_context'
-
+require 'test/support/inherited_stuff'
 
 class Assert::Suite
 
-  class BasicTest < Assert::Context
+  class BasicTests < Assert::Context
     desc "an basic suite"
     setup do
       @suite = Assert::Suite.new
     end
-    subject { @suite }
-
-    should have_instance_methods :ordered_tests, :results, :ordered_results
-    should have_instance_methods :count, :test_count, :result_count
-    should have_instance_methods :setup, :startup, :teardown, :shutdown
+    subject{ @suite }
 
-    should have_accessors :tests, :test_methods
-    should have_accessors :start_time, :end_time
-    should have_instance_method  :run_time
+    should have_imeths :ordered_tests, :results, :ordered_results, :run_time
+    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
-      assert_equal(
-        ["test_subclass_stuff", "test_mixin_stuff", "test_repeated"].sort,
-        subject.send(:local_public_test_methods, SubStuff).sort.collect(&:to_s)
-      )
+      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)
     end
 
-    should "have zero run time by default" do
+    should "have zero a run time by default" do
       assert_equal 0, subject.run_time
     end
 
   end
 
-  class WithTestsTest < Assert::Context
+  class WithTestsTests < Assert::Context
     desc "a suite with tests"
     setup do
+      ci = Factory.context_info(Factory.context_class)
       @suite = Assert::Suite.new
-      context_class = Factory.context_class
       @suite.tests = [
-        Factory.test("should do nothing", Factory.context_info(context_class)),
-        Factory.test("should pass", Factory.context_info(context_class)) do
-          assert(1==1)
-          refute(1==0)
-        end,
-        Factory.test("should fail", Factory.context_info(context_class)) do
-          ignore
-          assert(1==0)
-          refute(1==1)
-        end,
-        Factory.test("should be ignored", Factory.context_info(context_class)) do
-          ignore
-        end,
-        Factory.test("should skip", Factory.context_info(context_class)) do
-          skip
-          ignore
-          assert(1==1)
-        end,
-        Factory.test("should error", Factory.context_info(context_class)) do
-          raise Exception
-          ignore
-          assert(1==1)
-        end
+        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
     subject{ @suite }
 
+    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
@@ -107,10 +86,6 @@ class Assert::Suite
       assert_equal 1, subject.result_count(:error)
     end
 
-  end
-
-  class CountTest < WithTestsTest
-
     should "count its tests" do
       assert_equal subject.test_count, subject.count(:tests)
     end
@@ -146,58 +121,33 @@ class Assert::Suite
 
   end
 
-
-  class TestsTest < WithTestsTest
-
-    should "build test instances to run" do
-      assert_kind_of Assert::Test, subject.tests.first
-    end
-
-  end
-
-
-
-  class SetupTest < Assert::Context
-    desc "a suite with a setup"
+  class SetupTests < Assert::Context
+    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 do |setup_block|
-        @suite.setup(&setup_block)
-      end
-      @expected = "setup 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 @expected, subject
+      assert_equal "setup has been run", subject
     end
 
-  end
-
-
-
-  class SetupsTest < SetupTest
-    desc "when calling the setups method"
-    setup do
-      @setups = @suite.send(:setups)
-    end
-    subject{ @setups }
-
-    should "include the setup we defined on the suite" do
+    should "return the setup blocks with the #setups method" do
+      setups = @suite.send(:setups)
       @setup_blocks.each do |setup_block|
-        assert_includes setup_block, subject
+        assert_includes setup_block, setups
       end
     end
-  end
-
 
+  end
 
-  class TeardownTest < Assert::Context
+  class TeardownTests < Assert::Context
     desc "a suite with a teardown"
     setup do
       @teardown_status = nil
@@ -205,10 +155,7 @@ class Assert::Suite
       @teardown_blocks = []
       @teardown_blocks << ::Proc.new{ @teardown_status += " has been run" }
       @teardown_blocks << ::Proc.new{ @teardown_status = "teardown" }
-      @teardown_blocks.each do |teardown_block|
-        @suite.teardown(&teardown_block)
-      end
-      @expected = "teardown has been run"
+      @teardown_blocks.each{ |teardown_block| @suite.teardown(&teardown_block) }
     end
 
     should "set the teardown status to the correct message" do
@@ -216,22 +163,43 @@ class Assert::Suite
       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
+      end
+    end
+
   end
 
+  class ContextInfoTests < Assert::Context
+    desc "a suite's context info"
+    setup do
+      @caller = caller
+      @klass  = Assert::Context
+      @info   = Assert::Suite::ContextInfo.new(@klass, nil, @caller.first)
+    end
+    subject{ @info }
 
+    should have_readers :called_from, :first_caller, :klass, :file
 
-  class TeardownsTest < TeardownTest
-    desc "when calling the teardowns method"
-    setup do
-      @teardowns = @suite.send(:teardowns)
+    should "set its klass on init" do
+      assert_equal @klass, subject.klass
     end
-    subject{ @teardowns }
 
-    should "include the teardown we defined on the suite" do
-      @teardown_blocks.each do |teardown_block|
-        assert_includes teardown_block, subject
-      end
+    should "set its called_from to the first caller on init" do
+      assert_equal @caller.first, subject.first_caller
     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::Suite::ContextInfo.new(@klass)
+      assert_nil info.file
+    end
+
   end
 
 end

data/test/{test_test.rb → unit/test_tests.rb}

@@ -1,19 +1,15 @@
 require 'assert'
+require 'assert/test'
 
 class Assert::Test
 
-  class BasicTest < Assert::Context
-    desc "Assert test"
+  class BasicTests < Assert::Context
+    desc "a test obj"
     setup do
-      test_name = "should do something amazing"
       @test_code = lambda{ assert(true) }
-      context_desc = "context class"
-      @context_class = Factory.context_class do
-        desc context_desc
-      end
-      @context_info = Factory.context_info(@context_class)
-      @test = Factory.test(test_name, @context_info, @test_code)
-      @expected_name = [ context_desc, test_name.gsub(/^test:\s+should/, "should") ].join(" ")
+      @context_class = Factory.context_class { desc "context class" }
+      @context_info  = Factory.context_info(@context_class)
+      @test = Factory.test("should do something amazing", @context_info, @test_code)
     end
     teardown do
       TEST_ASSERT_SUITE.tests.clear
@@ -21,15 +17,16 @@ class Assert::Test
     subject{ @test }
 
     should have_readers :name, :code, :context_info
-    should have_accessor :results, :output
-    should have_instance_methods :run, :result_count, :context_class
-    should have_instance_methods *Assert::Result.types.keys.collect{|k| "#{k}_results".to_sym }
+    should have_accessors :results, :output
+    should have_imeths :run, :result_count, :context_class
+    should have_imeths *Assert::Result.types.keys.collect{ |k| "#{k}_results" }
 
-    should "set it's test name to the context description with the passed in name cleaned" do
-      assert_equal @expected_name, subject.name
+    should "build its name from the context description" do
+      exp_name = "context class should do something amazing"
+      assert_equal exp_name, subject.name
     end
 
-    should "set it's context class and code from its initialize" do
+    should "know it's context class and code" do
       assert_equal @context_class, subject.context_class
       assert_equal @test_code, subject.code
     end
@@ -39,22 +36,16 @@ class Assert::Test
     end
 
     should "have a custom inspect that only shows limited attributes" do
-      attributes_string = [ :name, :context_info, :results ].collect do |method|
+      attrs_string = [:name, :context_info, :results].collect do |method|
         "@#{method}=#{subject.send(method).inspect}"
       end.join(" ")
-      expected = "#<#{subject.class} #{attributes_string}>"
+      expected = "#<#{subject.class} #{attrs_string}>"
       assert_equal expected, subject.inspect
     end
 
   end
 
-
-  # testing <type>_results methods and result_count(<type>)
-  class ResultsTest < BasicTest
-    desc "methods from Assert::Result.types"
-  end
-
-  class PassFailIgnoreTest < ResultsTest
+  class PassFailIgnoreTotalTests < BasicTests
     setup do
       @test = Factory.test("pass fail ignore test", @context_info) do
         ignore("something")
@@ -68,74 +59,58 @@ class Assert::Test
     end
     subject{ @test }
 
-    should "return the pass results with #pass_results" do
+    should "know its pass results" do
       assert_kind_of Array, subject.pass_results
       assert_equal 2, subject.pass_results.size
       subject.pass_results.each do |result|
         assert_kind_of Assert::Result::Pass, result
       end
+      assert_equal subject.pass_results.size, subject.result_count(:pass)
     end
 
-    should "return the size of #pass_results with #result_count(:pass)" do
-      assert_equal(subject.pass_results.size, subject.result_count(:pass))
-    end
-
-    should "return the fail results with #fail_results" do
+    should "know its fail results" do
       assert_kind_of Array, subject.fail_results
       assert_equal 2, subject.fail_results.size
       subject.fail_results.each do |result|
         assert_kind_of Assert::Result::Fail, result
       end
+      assert_equal subject.fail_results.size, subject.result_count(:fail)
     end
 
-    should "return the size of #fail_results with #result_count(:fail)" do
-      assert_equal(subject.fail_results.size, subject.result_count(:fail))
-    end
-
-    should "return the ignore results with #ignore_results" do
+    should "know its ignore results" do
       assert_kind_of Array, subject.ignore_results
       assert_equal 2, subject.ignore_results.size
       subject.ignore_results.each do |result|
         assert_kind_of Assert::Result::Ignore, result
       end
+      assert_equal subject.ignore_results.size, subject.result_count(:ignore)
     end
 
-    should "return the size of #ignore_results with #result_count(:ignore)" do
-      assert_equal(subject.ignore_results.size, subject.result_count(:ignore))
-    end
-
-    should "return the total number of tests with #result_count" do
+    should "know the total number of results" do
       assert_equal(6, subject.result_count)
     end
 
   end
 
-
-
-  class SkipHandlingTest < ResultsTest
+  class SkipHandlingTests < BasicTests
     setup do
       @test = Factory.test("skip test", @context_info) { skip }
       @test.run
     end
     subject{ @test }
 
-    should "return the skip results with #skip_results" do
+    should "know its skip results" do
       assert_kind_of Array, subject.skip_results
       assert_equal 1, subject.skip_results.size
       subject.skip_results.each do |result|
         assert_kind_of Assert::Result::Skip, result
       end
-    end
-
-    should "return the size of #skip_results with #result_count(:skip)" do
-      assert_equal(subject.skip_results.size, subject.result_count(:skip))
+      assert_equal subject.skip_results.size, subject.result_count(:skip)
     end
 
   end
 
-
-
-  class ErrorHandlingTest < ResultsTest
+  class ErrorHandlingTests < BasicTests
     setup do
       @test = Factory.test("error test", @context_info) do
         raise StandardError, "WHAT"
@@ -144,23 +119,18 @@ class Assert::Test
     end
     subject{ @test }
 
-    should "return the error results with #error_results" do
+    should "know its error results" do
       assert_kind_of Array, subject.error_results
       assert_equal 1, subject.error_results.size
       subject.error_results.each do |result|
         assert_kind_of Assert::Result::Error, result
       end
-    end
-
-    should "return the size of #error_results with #result_count(:error)" do
-      assert_equal(subject.error_results.size, subject.result_count(:error))
+      assert_equal subject.error_results.size, subject.result_count(:error)
     end
 
   end
 
-
-
-  class ComparingTest < BasicTest
+  class ComparingTests < BasicTests
     desc "<=> another test"
     setup do
       @test = Factory.test("mmm")
@@ -184,19 +154,19 @@ class Assert::Test
 
   end
 
-  class CaptureOutTest < BasicTest
+  class CaptureOutTests < BasicTests
     desc "when capturing std out"
-    setup {
+    setup do
       @test = Factory.test("stdout") {
         puts "std out from the test"
         assert true
       }
       @orig_show = Assert.config.show_output
       Assert.config.show_output false
-    }
-    teardown {
+    end
+    teardown do
       Assert.config.show_output @orig_show
-    }
+    end
 
     should "capture any io from the test" do
       @test.run
@@ -205,30 +175,28 @@ class Assert::Test
 
   end
 
-  class FullCaptureOutTest < CaptureOutTest
+  class FullCaptureOutTests < CaptureOutTests
     desc "across setup, teardown, and meth calls"
     setup do
-      @test = Factory.test("fullstdouttest") {
+      @test = Factory.test("fullstdouttest") do
         puts "std out from the test"
-        assert a_method_an_assert_calls.inspect
-      }
+        assert a_method_an_assert_calls
+      end
       @test.context_class.setup { puts "std out from the setup" }
       @test.context_class.teardown { puts "std out from the teardown" }
       @test.context_class.send(:define_method, "a_method_an_assert_calls") do
         puts "std out from a method an assert called"
-        true
       end
     end
 
-    should "collect it on itself in the output accessor" do
+    should "collect all stdout in the output accessor" do
       @test.run
 
-      assert_equal([
-        "std out from the setup",
-        "std out from the test",
-        "std out from a method an assert called",
-        "std out from the teardown\n"
-      ].join("\n"), @test.output)
+      exp_out = "std out from the setup\n"\
+                "std out from the test\n"\
+                "std out from a method an assert called\n"\
+                "std out from the teardown\n"
+      assert_equal(exp_out, @test.output)
     end
   end