assert 2.0.0.rc.1 → 2.0.0

data/test/{context_test.rb → unit/context_tests.rb}

@@ -1,8 +1,9 @@
 require 'assert'
+require 'assert/context'
 
 class Assert::Context
 
-  class BasicTest < Assert::Context
+  class BasicTests < Assert::Context
     desc "Assert context"
     setup do
       @test = Factory.test
@@ -14,46 +15,36 @@ class Assert::Context
     end
     subject{ @context }
 
-    should have_instance_methods :assert, :assert_not, :refute
-    should have_instance_methods :skip, :pass, :fail, :flunk, :ignore
-    should have_instance_methods :subject
+    should have_imeths :assert, :assert_not, :refute
+    should have_imeths :skip, :pass, :fail, :flunk, :ignore
+    should have_imeths :subject
 
     def test_should_collect_context_info
-      assert_match /test\/context_test.rb$/, @__running_test__.context_info.file
-      assert_equal self.class, @__running_test__.context_info.klass
+      this = @__running_test__
+      assert_match /test\/unit\/context_tests.rb$/, this.context_info.file
+      assert_equal self.class, this.context_info.klass
     end
 
   end
 
-
-
-  class SkipTest < BasicTest
+  class SkipTests < BasicTests
     desc "skip method"
     setup do
       @skip_msg = "I need to implement this in the future."
-      begin
-        @context.skip(@skip_msg)
-      rescue Exception => @exception
-      end
+      begin; @context.skip(@skip_msg); rescue Exception => @exception; end
       @result = Factory.skip_result("something", @exception)
     end
     subject{ @result }
 
-    should "raise a test skipped exception when called" do
+    should "raise a test skipped exception and set its message" do
       assert_kind_of Assert::Result::TestSkipped, @exception
-    end
-    should "raise the exception with the message passed to it" do
       assert_equal @skip_msg, @exception.message
-    end
-    should "set the message passed to it on the result" do
       assert_equal @skip_msg, subject.message
     end
 
   end
 
-
-
-  class IgnoreTest < BasicTest
+  class IgnoreTests < BasicTests
     desc "ignore method"
     setup do
       @ignore_msg = "Ignore this for now, will do later."
@@ -61,18 +52,14 @@ class Assert::Context
     end
     subject{ @result }
 
-    should "create an ignore result" do
+    should "create an ignore result and set its message" do
       assert_kind_of Assert::Result::Ignore, subject
-    end
-    should "set the messaged passed to it on the result" do
       assert_equal @ignore_msg, subject.message
     end
 
   end
 
-
-
-  class PassTest < BasicTest
+  class PassTests < BasicTests
     desc "pass method"
     setup do
       @pass_msg = "That's right, it works."
@@ -80,18 +67,14 @@ class Assert::Context
     end
     subject{ @result }
 
-    should "create a pass result" do
+    should "create a pass result and set its message" do
       assert_kind_of Assert::Result::Pass, subject
-    end
-    should "set the messaged passed to it on the result" do
       assert_equal @pass_msg, subject.message
     end
 
   end
 
-
-
-  class FlunkTests < BasicTest
+  class FlunkTests < BasicTests
     desc "flunk method"
     setup do
       @flunk_msg = "It flunked."
@@ -99,53 +82,36 @@ class Assert::Context
     end
     subject{ @result }
 
-    should "create a fail result" do
+    should "create a fail result and set its message" do
       assert_kind_of Assert::Result::Fail, subject
-    end
-    should "set the message passed to it on the result" do
       assert_equal @flunk_msg, subject.message
     end
 
   end
 
-  class FailTests < BasicTest
+  class FailTests < BasicTests
     desc "fail method"
     setup do
       @result = @context.fail
     end
     subject{ @result }
 
-    should "create a fail result" do
+    should "create a fail result and set its backtrace" do
       assert_kind_of Assert::Result::Fail, subject
-    end
-    should "set the calling backtrace on the result" do
-      assert_kind_of Array, subject.backtrace
       assert_equal Factory.context_info_called_from, subject.trace
-    end
-  end
-
-  class StringMessageTests < FailTests
-    desc "with a string message"
-    setup do
-      @fail_msg = "Didn't work"
-      @result = @context.fail(@fail_msg)
-    end
-
-    should "set the message passed to it on the result" do
-      assert_equal @fail_msg, subject.message
+      assert_kind_of Array, subject.backtrace
     end
 
-  end
-
-  class ProcMessageTests < FailTests
-    desc "with a proc message"
-    setup do
-      @fail_msg = ::Proc.new{ "Still didn't work" }
-      @result = @context.fail(@fail_msg)
+    should "set any given result message" do
+      fail_msg = "Didn't work"
+      result = @context.fail(fail_msg)
+      assert_equal fail_msg, result.message
     end
 
-    should "set the message passed to it on the result" do
-      assert_equal @fail_msg.call, subject.message
+    should "set any given result message evaluated from a proc" do
+      fail_msg = ::Proc.new{ "Still didn't work" }
+      result = @context.fail(fail_msg)
+      assert_equal fail_msg.call, result.message
     end
 
   end
@@ -177,107 +143,65 @@ class Assert::Context
 
   end
 
-
-
-  class AssertTest < BasicTest
+  class AssertTests < BasicTests
     desc "assert method"
     setup do
       @fail_desc = "my fail desc"
       @what_failed = "what failed"
     end
 
-    class WithTruthyAssertionTest < AssertTest
-      desc "with a truthy assertion"
-      setup do
-        @result = @context.assert(true, @fail_desc, @what_failed)
-      end
-      subject{ @result }
-
-      should "return a pass result" do
-        assert_kind_of Assert::Result::Pass, subject
-        assert_nil subject.message
-      end
-
+    should "return a pass result given a `true` assertion" do
+      result = subject.assert(true, @fail_desc, @what_failed)
+      assert_kind_of Assert::Result::Pass, result
+      assert_nil result.message
     end
 
-    class WithFalseAssertionTest < AssertTest
-      desc "with a false assertion"
-      setup do
-        @result = @context.assert(false, @fail_desc, @what_failed)
-      end
-      subject{ @result }
-
-      should "return a fail result" do
-        assert_kind_of Assert::Result::Fail, subject
-        assert_equal [@fail_desc, @what_failed].join("\n"), subject.message
-      end
-
+    should "return a fail result given a `false` assertion" do
+      result = subject.assert(false, @fail_desc, @what_failed)
+      assert_kind_of Assert::Result::Fail, result
+      assert_equal [@fail_desc, @what_failed].join("\n"), result.message
     end
 
-    # extras
-
-    should "return a pass result with a truthy (34) assertion" do
+    should "return a pass result given a \"truthy\" assertion" do
       assert_kind_of Assert::Result::Pass, subject.assert(34)
     end
 
-    should "return a fail result with a nil assertion" do
+    should "return a fail result gievn a `nil` assertion" do
       assert_kind_of Assert::Result::Fail, subject.assert(nil)
     end
 
   end
 
-
-
-  class AssertNotTest < BasicTest
+  class AssertNotTests < BasicTests
     desc "assert_not method"
     setup do
       @fail_desc = "my fail desc"
+      @what_failed = "Failed assert_not: assertion was <true>."
     end
 
-    class WithTruthyAssertionTest < AssertNotTest
-      desc "with a truthy assertion"
-      setup do
-        @what_failed = "Failed assert_not: assertion was <true>."
-        @result = @context.assert_not(true, @fail_desc)
-      end
-      subject{ @result }
-
-      should "return a fail result" do
-        assert_kind_of Assert::Result::Fail, subject
-        assert_equal [@fail_desc, @what_failed].join("\n"), subject.message
-      end
-
+    should "return a fail result given a `true` assertion" do
+      result = subject.assert_not(true, @fail_desc)
+      assert_kind_of Assert::Result::Fail, result
+      assert_equal [@fail_desc, @what_failed].join("\n"), result.message
     end
 
-    class WithFalseAssertionTest < AssertNotTest
-      desc "with a false assertion"
-      setup do
-        @result = @context.assert_not(false, @fail_desc)
-      end
-      subject{ @result }
-
-      should "return a pass result" do
-        assert_kind_of Assert::Result::Pass, subject
-        assert_nil subject.message
-      end
-
+    should "return a pass result given a `false` assertion" do
+      result = subject.assert_not(false, @fail_desc)
+      assert_kind_of Assert::Result::Pass, result
+      assert_nil result.message
     end
 
-    # extras
-
-    should "return a fail result with a truthy (34) assertion" do
+    should "return a fail result given a \"truthy\" assertion" do
       assert_kind_of Assert::Result::Fail, subject.assert_not(34)
     end
 
-    should "return a pass result with a nil assertion" do
+    should "return a pass result given a `nil` assertion" do
       assert_kind_of Assert::Result::Pass, subject.assert_not(nil)
     end
 
   end
 
-
-
-  class SubjectTest < BasicTest
+  class SubjectTests < BasicTests
     desc "subject method"
     setup do
       expected = @expected = "amazing"
@@ -295,9 +219,7 @@ class Assert::Context
 
   end
 
-
-
-  class InspectTest < BasicTest
+  class InspectTests < BasicTests
     desc "inspect method"
     setup do
       @expected = "#<#{@context.class}>"

data/test/{macro_test.rb → unit/macro_tests.rb}

@@ -1,12 +1,13 @@
 require 'assert'
-
 require 'assert/macro'
 
 class Assert::Macro
 
-  class BaseTest < Assert::Context
+  class BaseTests < Assert::Context
     desc "a macro"
-    setup { @macro = Assert::Macro.new {} }
+    setup do
+      @macro = Assert::Macro.new {}
+    end
     subject { @macro }
 
     should "have an accessor for its (optional) name" do
@@ -27,14 +28,12 @@ class Assert::Macro
     end
 
     should "complain if you create a macro without a block" do
-      assert_raises ArgumentError do
-        Assert::Macro.new
-      end
+      assert_raises(ArgumentError) { Assert::Macro.new }
     end
 
   end
 
-  class InstanceMethodsTest < Assert::Context
+  class InstanceMethodsTests < Assert::Context
     desc "a class with instance methods"
     subject do
       class ::InstExample
@@ -52,9 +51,10 @@ class Assert::Macro
     should not_have_instance_methods :method_8, :method_9
     should not_have_imeth :method_10
     should not_have_imeths :method_11, :method_12
+
   end
 
-  class ClassMethodsTest < Assert::Context
+  class ClassMethodsTests < Assert::Context
     desc "a class with class methods"
     subject do
       class ::ClassExample
@@ -74,9 +74,10 @@ class Assert::Macro
     should not_have_class_methods :method_8, :method_9
     should not_have_cmeth :method_10
     should not_have_cmeths :method_11, :method_12
+
   end
 
-  class ReadersTest < Assert::Context
+  class ReadersTests < Assert::Context
     desc "a class with readers"
     subject do
       class ::ReaderExample
@@ -94,9 +95,10 @@ class Assert::Macro
     should not_have_reader :method_8, :method_9
     should not_have_readers :method_10
     should not_have_readers :method_11, :method_12
+
   end
 
-  class WritersTest < Assert::Context
+  class WritersTests < Assert::Context
     desc "a class with writers"
     subject do
       class ::WriterExample
@@ -114,9 +116,10 @@ class Assert::Macro
     should not_have_writer :method_8, :method_9
     should not_have_writers :method_10
     should not_have_writers :method_11, :method_12
+
   end
 
-  class AccessorsTest < Assert::Context
+  class AccessorsTests < Assert::Context
     desc "a class with accessors"
     subject do
       class ::AccessorExample
@@ -134,6 +137,7 @@ class Assert::Macro
     should not_have_accessor :method_8, :method_9
     should not_have_accessors :method_10
     should not_have_accessors :method_11, :method_12
+
   end
 
 end

data/test/{result_test.rb → unit/result_tests.rb}

@@ -1,12 +1,13 @@
 require 'assert'
-
 require 'assert/result'
 
 module Assert::Result
 
-  class BacktraceTest < Assert::Context
+  class BacktraceTests < Assert::Context
     desc "a result backtrace"
-    setup{ @backtrace = Backtrace.new(caller) }
+    setup do
+      @backtrace = Backtrace.new(caller)
+    end
     subject { @backtrace }
 
     should have_instance_methods :to_s, :filtered
@@ -26,9 +27,10 @@ module Assert::Result
     should "default itself when created from nil" do
       assert_equal ["No backtrace"], Backtrace.new
     end
+
   end
 
-  class BaseTest < Assert::Context
+  class BaseTests < Assert::Context
     desc "a base result"
     setup do
       @test = Factory.test("a test name")
@@ -37,7 +39,7 @@ module Assert::Result
     subject{ @result }
 
     should have_readers :test, :message, :backtrace
-    should have_instance_methods :test_name, :name, :to_sym, :to_s, :trace
+    should have_imeths :test_name, :name, :to_sym, :to_s, :trace
 
     Assert::Result.types.keys.each do |type|
       should "respond to the instance method ##{type}?" do
@@ -58,12 +60,14 @@ module Assert::Result
     end
 
     should "show only its class and message when inspected" do
-      assert_equal "#<#{subject.class} @message=#{subject.message.inspect}>", subject.inspect
+      exp = "#<#{subject.class} @message=#{subject.message.inspect}>"
+      assert_equal exp, subject.inspect
     end
 
   end
 
-  class ToStringTest < BaseTest
+  class ToStringTests < BaseTests
+
     should "include its test context name in the to_s" do
       assert subject.to_s.include?(subject.test_name)
     end
@@ -85,7 +89,7 @@ module Assert::Result
     end
   end
 
-  class PassTest < Assert::Context
+  class PassTests < Assert::Context
     desc "a pass result"
     setup do
       @test = Factory.test("a test name")
@@ -114,9 +118,10 @@ module Assert::Result
     should "include PASS in its to_s" do
       assert subject.to_s.include?("PASS")
     end
+
   end
 
-  class IgnoreTest < Assert::Context
+  class IgnoreTests < Assert::Context
     desc "an ignore result"
     setup do
       @test = Factory.test("a test name")
@@ -145,17 +150,10 @@ module Assert::Result
     should "include IGNORE in its to_s" do
       assert subject.to_s.include?("IGNORE")
     end
-  end
-
-  class FailureRuntimeErrorTest < Assert::Context
-
-    should "be a runtime error" do
-      assert_kind_of RuntimeError, Assert::Result::TestFailure.new
-    end
 
   end
 
-  class FailTest < Assert::Context
+  class FailTests < Assert::Context
     desc "a fail result"
     setup do
       @test = Factory.test("a test name")
@@ -163,6 +161,10 @@ module Assert::Result
     end
     subject { @result }
 
+    should "use a runtime error (TestFailure) for controlling flow" do
+      assert_kind_of RuntimeError, Assert::Result::TestFailure.new
+    end
+
     should "be fail?" do
       assert_equal true, subject.fail?
     end
@@ -184,17 +186,10 @@ module Assert::Result
     should "include FAIL in its to_s" do
       assert subject.to_s.include?("FAIL")
     end
-  end
-
-  class SkippedRuntimeErrorTest < Assert::Context
-
-    should "be a runtime error" do
-      assert_kind_of RuntimeError, Assert::Result::TestSkipped.new
-    end
 
   end
 
-  class SkipTest < Assert::Context
+  class SkipTests < Assert::Context
     desc "a skip result"
     setup do
       @test = Factory.test("a test name")
@@ -208,6 +203,10 @@ module Assert::Result
     end
     subject { @result }
 
+    should "use a runtime error (TestSkipped) for controlling flow" do
+      assert_kind_of RuntimeError, Assert::Result::TestSkipped.new
+    end
+
     should "be skip?" do
       assert_equal true, subject.skip?
     end
@@ -229,9 +228,10 @@ module Assert::Result
     should "include SKIP in its to_s" do
       assert subject.to_s.include?("SKIP")
     end
+
   end
 
-  class ErrorTest < Assert::Context
+  class ErrorTests < Assert::Context
     desc "an error result"
     setup do
       @test = Factory.test("a test name")
@@ -270,6 +270,7 @@ module Assert::Result
     should "have a trace created from the original exception's unfiltered backtrace" do
       assert_equal @exception.backtrace.join("\n"), subject.trace
     end
+
   end
 
 end