assert 2.18.3 → 2.18.4

data/test/unit/file_line_tests.rb

@@ -4,7 +4,9 @@ require "assert/file_line"
 class Assert::FileLine
   class UnitTests < Assert::Context
     desc "Assert::FileLine"
-    subject { Assert::FileLine }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::FileLine }
 
     let(:file1) { "#{Factory.path}_tests.rb" }
     let(:line1) { Factory.integer.to_s }
@@ -43,9 +45,7 @@ class Assert::FileLine
 
   class InitTests < UnitTests
     desc "when init"
-    subject { file_line1 }
-
-    let(:file_line1) { Assert::FileLine.new(file1, line1) }
+    subject { unit_class.new(file1, line1) }
 
     should have_readers :file, :line
 
@@ -53,11 +53,11 @@ class Assert::FileLine
       assert_that(subject.file).equals(file1)
       assert_that(subject.line).equals(line1)
 
-      file_line = Assert::FileLine.new(file1)
+      file_line = unit_class.new(file1)
       assert_that(file_line.file).equals(file1)
       assert_that(file_line.line).equals("")
 
-      file_line = Assert::FileLine.new
+      file_line = unit_class.new
       assert_that(file_line.file).equals("")
       assert_that(file_line.line).equals("")
     end
@@ -67,8 +67,8 @@ class Assert::FileLine
     end
 
     should "know if it is equal to another file line" do
-      yes = Assert::FileLine.new(file1, line1)
-      no = Assert::FileLine.new("#{Factory.path}_tests.rb", Factory.integer.to_s)
+      yes = unit_class.new(file1, line1)
+      no = unit_class.new("#{Factory.path}_tests.rb", Factory.integer.to_s)
 
       assert_that(subject).equals(yes)
       assert_not_equal no,  subject

data/test/unit/macro_tests.rb

@@ -4,9 +4,14 @@ require "assert/macro"
 class Assert::Macro
   class UnitTests < Assert::Context
     desc "Assert::Macro"
-    subject { macro1 }
+    subject { unit_class }
 
-    let(:macro1) { Assert::Macro.new {} }
+    let(:unit_class) { Assert::Macro }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new {} }
 
     should "have an accessor for its (optional) name" do
       assert_that(subject).responds_to(:name)
@@ -14,11 +19,11 @@ class Assert::Macro
     end
 
     should "default its name if no given" do
-      assert_that((Assert::Macro.new {}).name).equals("run this macro")
+      assert_that((unit_class.new {}).name).equals("run this macro")
     end
 
     should "initialize with a given name" do
-      assert_that((Assert::Macro.new("test") {}).name).equals("test")
+      assert_that((unit_class.new("test") {}).name).equals("test")
     end
 
     should "be a Proc" do
@@ -26,7 +31,7 @@ class Assert::Macro
     end
 
     should "complain if you create a macro without a block" do
-      assert_that(-> { Assert::Macro.new }).raises(ArgumentError)
+      assert_that(-> { unit_class.new }).raises(ArgumentError)
     end
   end
 

data/test/unit/result_tests.rb

@@ -6,7 +6,9 @@ require "assert/file_line"
 module Assert::Result
   class UnitTests < Assert::Context
     desc "Assert::Result"
-    subject { Assert::Result }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Result }
 
     let(:test1) { Factory.test("a test name") }
 
@@ -32,9 +34,9 @@ module Assert::Result
     end
   end
 
-  class BaseTests < UnitTests
-    desc "Base"
-    subject { result1 }
+  class InitBaseTests < UnitTests
+    desc "Base when init"
+    subject { Base.new(given_data1) }
 
     let(:given_data1) {
       {
@@ -47,7 +49,6 @@ module Assert::Result
         :backtrace      => Backtrace.new(Factory.backtrace)
       }
     }
-    let(:result1) { Base.new(given_data1) }
 
     should have_cmeths :type, :name, :for_test
     should have_imeths :type, :name, :test_name, :test_file_line
@@ -226,11 +227,9 @@ module Assert::Result
     end
   end
 
-  class PassTests < UnitTests
-    desc "Pass"
-    subject { result1 }
-
-    let(:result1) { Pass.new({}) }
+  class InitPassTests < UnitTests
+    desc "Pass when init"
+    subject { Pass.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:pass)
@@ -239,11 +238,9 @@ module Assert::Result
     end
   end
 
-  class IgnoreTests < UnitTests
-    desc "Ignore"
-    subject { result1 }
-
-    let(:result1) { Ignore.new({}) }
+  class InitIgnoreTests < UnitTests
+    desc "Ignore when init"
+    subject { Ignore.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:ignore)
@@ -252,8 +249,8 @@ module Assert::Result
     end
   end
 
-  class HaltingTestResultErrorTests < UnitTests
-    desc "HaltingTestResultError"
+  class InitHaltingTestResultErrorTests < UnitTests
+    desc "HaltingTestResultError when init"
     subject { HaltingTestResultError.new }
 
     should have_accessors :assert_with_bt
@@ -263,20 +260,18 @@ module Assert::Result
     end
   end
 
-  class TestFailureTests < UnitTests
-    desc "TestFailure"
-    subject { TestFailure }
+  class InitTestFailureTests < UnitTests
+    desc "TestFailure when init"
+    subject { TestFailure.new }
 
     should "be a halting test result error" do
-      assert_that(subject.new).is_kind_of(HaltingTestResultError)
+      assert_that(subject).is_kind_of(HaltingTestResultError)
     end
   end
 
-  class FailTests < UnitTests
-    desc "Fail"
-    subject { result1 }
-
-    let(:result1) { Fail.new({}) }
+  class InitFailTests < UnitTests
+    desc "Fail when init"
+    subject { Fail.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:fail)
@@ -311,20 +306,18 @@ module Assert::Result
     end
   end
 
-  class TestSkippedTests < UnitTests
-    desc "TestSkipped"
-    subject { TestSkipped }
+  class InitTestSkippedTests < UnitTests
+    desc "TestSkipped when init"
+    subject { TestSkipped.new }
 
     should "be a halting test result error" do
-      assert_that(subject.new).is_kind_of(HaltingTestResultError)
+      assert_that(subject).is_kind_of(HaltingTestResultError)
     end
   end
 
-  class SkipTests < UnitTests
-    desc "Skip"
-    subject { result1 }
-
-    let(:result1) { Skip.new({}) }
+  class InitSkipTests < UnitTests
+    desc "Skip when init"
+    subject { Skip.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:skip)
@@ -359,11 +352,9 @@ module Assert::Result
     end
   end
 
-  class ErrorTests < UnitTests
-    desc "Error"
-    subject { result1 }
-
-    let(:result1) { Error.new({}) }
+  class InitErrorTests < UnitTests
+    desc "Error when init"
+    subject { Error.new({}) }
 
     should "know its class-level type/name" do
       assert_that(subject.class.type).equals(:error)
@@ -388,11 +379,9 @@ module Assert::Result
     end
   end
 
-  class BacktraceTests < UnitTests
-    desc "Backtrace"
-    subject { backtrace1 }
-
-    let(:backtrace1) { Backtrace.new(Factory.backtrace) }
+  class InitBacktraceTests < UnitTests
+    desc "Backtrace when init"
+    subject { Backtrace.new(Factory.backtrace) }
 
     should have_cmeths :parse, :to_s
     should have_imeths :filtered

data/test/unit/runner_tests.rb

@@ -10,7 +10,9 @@ require "assert/view"
 class Assert::Runner
   class UnitTests < Assert::Context
     desc "Assert::Runner"
-    subject { Assert::Runner }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Runner }
 
     should "include the config helpers" do
       assert_that(subject).includes(Assert::ConfigHelpers)
@@ -19,7 +21,7 @@ class Assert::Runner
 
   class InitTests < UnitTests
     desc "when init"
-    subject { runner1 }
+    subject { unit_class.new(config1) }
 
     setup do
       config1.suite Assert::DefaultSuite.new(config1)
@@ -27,7 +29,6 @@ class Assert::Runner
     end
 
     let(:config1) { Factory.modes_off_config }
-    let(:runner1) { Assert::Runner.new(config1) }
 
     should have_readers :config
     should have_imeths :runner, :run
@@ -46,6 +47,7 @@ class Assert::Runner
 
   class RunTests < InitTests
     desc "and run"
+    subject { runner_class1.new(config1) }
 
     setup do
       @view_output = ""
@@ -57,26 +59,24 @@ class Assert::Runner
       config1.view  view_class.new(config1, StringIO.new(@view_output, "w+"))
       config1.suite.on_test(test1)
 
-      @result = subject.run
+      @result_count = subject.run
     end
 
-    let(:runner_class1) { Class.new(Assert::Runner) { include CallbackMixin } }
+    let(:runner_class1) { Class.new(unit_class) { include CallbackMixin } }
     let(:ci1) { Factory.context_info(Factory.modes_off_context_class) }
     let(:test1) { Factory.test("should pass", ci1){ assert(1==1) } }
-    let(:runner1) { runner_class1.new(config1) }
 
     should "return the fail+error result count as an integer exit code" do
-      assert_that(@result).equals(0)
+      assert_that(@result_count).equals(0)
 
       fail_count  = Factory.integer
       error_count = Factory.integer
       Assert.stub(subject, :fail_result_count){ fail_count }
       Assert.stub(subject, :error_result_count){ error_count }
       Assert.stub(test1, :run){ } # no-op
-      result = runner1.run
+      result_count = subject.run
 
-      exp = fail_count + error_count
-      assert_that(result).equals(exp)
+      assert_that(result_count).equals(fail_count + error_count)
     end
 
     should "run all callbacks on itself, the suite and the view" do

data/test/unit/suite_tests.rb

@@ -6,10 +6,11 @@ require "assert/test"
 require "test/support/inherited_stuff"
 
 class Assert::Suite
-
   class UnitTests < Assert::Context
     desc "Assert::Suite"
-    subject { Assert::Suite }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Suite }
 
     should "include the config helpers" do
       assert_that(subject).includes(Assert::ConfigHelpers)
@@ -23,10 +24,9 @@ class Assert::Suite
 
   class InitTests < UnitTests
     desc "when init"
-    subject { suite1 }
+    subject { unit_class.new(config1) }
 
     let(:config1) { Factory.modes_off_config }
-    let(:suite1)  { Assert::Suite.new(config1) }
 
     should have_readers :config, :test_methods, :setups, :teardowns
     should have_accessors :start_time, :end_time
@@ -84,8 +84,8 @@ class Assert::Suite
 
     should "add setup procs" do
       status = nil
-      suite1.setup{ status = "setups" }
-      suite1.startup{ status += " have been run" }
+      subject.setup{ status = "setups" }
+      subject.startup{ status += " have been run" }
 
       assert_that(subject.setups.count).equals(2)
       subject.setups.each(&:call)
@@ -94,8 +94,8 @@ class Assert::Suite
 
     should "add teardown procs" do
       status = nil
-      suite1.teardown{ status = "teardowns" }
-      suite1.shutdown{ status += " have been run" }
+      subject.teardown{ status = "teardowns" }
+      subject.shutdown{ status += " have been run" }
 
       assert_that(subject.teardowns.count).equals(2)
       subject.teardowns.each(&:call)
@@ -107,7 +107,7 @@ class Assert::Suite
     desc "with tests loaded"
 
     setup do
-      tests1.each{ |test| suite1.on_test(test) }
+      tests1.each{ |test| subject.on_test(test) }
     end
 
     let(:ci1) { proc{ Factory.context_info(Factory.modes_off_context_class) } }

data/test/unit/test_tests.rb

@@ -8,7 +8,9 @@ require "assert/result"
 class Assert::Test
   class UnitTests < Assert::Context
     desc "Assert::Test"
-    subject { Assert::Test }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Test }
 
     let(:context_class1) { Factory.modes_off_context_class { desc "context class" } }
     let(:context_info1)  { Factory.context_info(context_class1) }
@@ -68,7 +70,7 @@ class Assert::Test
 
   class InitWithDataTests < UnitTests
     desc "when init with data"
-    subject { test1 }
+    subject { unit_class.new(meta_data1.merge(run_data1)) }
 
     let(:file_line1) { Assert::FileLine.new(Factory.string, Factory.integer.to_s) }
     let(:meta_data1) {
@@ -86,7 +88,6 @@ class Assert::Test
         :code         => test_code1
       }
     }
-    let(:test1) { Assert::Test.new(meta_data1.merge(run_data1)) }
 
     should have_imeths :file_line, :file_name, :line_num
     should have_imeths :name, :output, :run_time
@@ -104,7 +105,7 @@ class Assert::Test
     end
 
     should "default its attrs" do
-      test = Assert::Test.new
+      test = unit_class.new
 
       assert_that(test.file_line).equals(Assert::FileLine.parse(""))
       assert_that(test.name).equals("")
@@ -137,7 +138,13 @@ class Assert::Test
   class PassFailIgnoreHandlingTests < UnitTests
     include Assert::Test::TestHelpers
 
-    subject { test1 }
+    subject {
+      Factory.test("pass fail ignore test", context_info1) do
+        ignore("something")
+        assert(true)
+        assert(false)
+      end
+    }
 
     setup do
       subject.context_class.setup do
@@ -153,14 +160,6 @@ class Assert::Test
       subject.run(&test_run_callback)
     end
 
-    let(:test1) {
-      Factory.test("pass fail ignore test", context_info1) do
-        ignore("something")
-        assert(true)
-        assert(false)
-      end
-    }
-
     should "capture results in the test and any setups/teardowns" do
       assert_that(test_run_results.size).equals(9)
       test_run_results.each do |result|
@@ -336,70 +335,64 @@ class Assert::Test
 
   class ComparingTests < UnitTests
     desc "<=> another test"
-    subject { test1 }
-
-    let(:test1) { Factory.test("mmm") }
+    subject { Factory.test("mmm") }
 
     should "return 1 with a test named 'aaa' (greater than it)" do
-      result = test1 <=> Factory.test("aaa")
-      assert_that(result).equals(1)
+      assert_that(subject <=> Factory.test("aaa")).equals(1)
     end
 
     should "return 0 with a test named the same" do
-      result = test1 <=> Factory.test(test1.name)
-      assert_that(result).equals(0)
+      assert_that(subject <=> Factory.test(subject.name)).equals(0)
     end
 
     should "return -1 with a test named 'zzz' (less than it)" do
-      result = test1 <=> Factory.test("zzz")
-      assert_that(result).equals(-1)
+      assert_that(subject <=> Factory.test("zzz")).equals(-1)
     end
   end
 
   class CaptureOutTests < UnitTests
     desc "when capturing std out"
-
-    let(:capture_config1) { Assert::Config.new(:capture_output => true) }
-    let(:test1) {
+    subject {
       Factory.test("stdout", capture_config1) do
         puts "std out from the test"
         assert true
       end
     }
 
+    let(:capture_config1) { Assert::Config.new(:capture_output => true) }
+
     should "capture any io from the test" do
-      test1.run
-      assert_that(test1.output).equals("std out from the test\n")
+      subject.run
+      assert_that(subject.output).equals("std out from the test\n")
     end
   end
 
   class FullCaptureOutTests < CaptureOutTests
     desc "across setup, teardown, and meth calls"
-
-    setup do
-      test1.context_class.setup{ puts "std out from the setup" }
-      test1.context_class.teardown{ puts "std out from the teardown" }
-      test1.context_class.send(:define_method, "a_method_an_assert_calls") do
-        puts "std out from a method an assert called"
-      end
-    end
-
-    let(:test1) {
+    subject {
       Factory.test("fullstdouttest", capture_config1) do
         puts "std out from the test"
         assert a_method_an_assert_calls
       end
     }
 
+    setup do
+      subject.context_class.setup{ puts "std out from the setup" }
+      subject.context_class.teardown{ puts "std out from the teardown" }
+      subject.context_class.send(:define_method, "a_method_an_assert_calls") do
+        puts "std out from a method an assert called"
+      end
+    end
+
     should "collect all stdout in the output accessor" do
-      test1.run
+      subject.run
 
       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_that(test1.output).equals(exp_out)
+      assert_that(subject.output).equals(exp_out)
     end
   end
 end