assert 0.1.0 → 0.2.0

data/test/context/class_methods_test.rb

@@ -1,29 +1,21 @@
 require 'assert'
 
-class Assert::Context::ClassMethodsTest < Assert::Context
-  desc "Assert context class"
-  setup do
-    @test = Factory.test
-    @context_class = @test.context_class
-  end
-  subject{ @context_class }
-
-  CLASS_METHODS = [
-    :setup_once, :before_once, :teardown_once, :after_once,
-    :setup, :before, :teardown, :after,
-    :setup_blocks, :all_setup_blocks, :teardown_blocks, :all_teardown_blocks,
-    :desc, :description, :descriptions, :full_description,
-    :subject,
-    :should
-  ]
-  CLASS_METHODS.each do |class_method|
-    should "respond to the class method ##{class_method}" do
-      assert_respond_to subject, class_method
+class Assert::Context
+
+  class ClassMethodsTest < Assert::Context
+    desc "Assert context class"
+    setup do
+      @test = Factory.test
+      @context_class = @test.context_class
     end
-  end
+    teardown do
+      TEST_ASSERT_SUITE.clear
+    end
+    subject{ @context_class }
 
-  teardown do
-    TEST_ASSERT_SUITE.clear
+    should have_instance_methods :setup_once, :before_once, :setup, :before, :setups
+    should have_instance_methods :teardown_once, :after_once, :teardown, :after, :teardowns
+    should have_instance_methods :description, :desc, :subject, :should, :should_eventually, :should_skip
   end
 
 
@@ -31,20 +23,19 @@ class Assert::Context::ClassMethodsTest < Assert::Context
   class SetupOnceTest < ClassMethodsTest
     desc "setup_once method"
     setup do
-      setup_block = @setup_block = lambda{ something_once = true }
+      setup_block = @setup_block = ::Proc.new{ something_once = true }
       @context_class = Factory.context_class do
         setup_once(&setup_block)
       end
-      @setup_blocks = Assert.suite.setup_blocks
+      @setup_blocks = Assert.suite.send(:setups)
+    end
+    teardown do
+      Assert.suite.send(:setups).reject!{|b| b == @setup_block }
     end
     subject{ @setup_blocks }
 
     should "add the block to the suite's collection of setup blocks" do
-      assert_includes subject, @setup_block
-    end
-
-    teardown do
-      Assert.suite.setup_blocks.reject!{|b| b == @setup_block }
+      assert_includes @setup_block, subject
     end
 
   end
@@ -54,20 +45,19 @@ class Assert::Context::ClassMethodsTest < Assert::Context
   class TeardownOnceTest < ClassMethodsTest
     desc "teardown_once method"
     setup do
-      teardown_block = @teardown_block = lambda{ something_once = true }
+      teardown_block = @teardown_block = ::Proc.new{ something_once = true }
       @context_class = Factory.context_class do
         teardown_once(&teardown_block)
       end
-      @teardown_blocks = Assert.suite.teardown_blocks
+      @teardown_blocks = Assert.suite.send(:teardowns)
+    end
+    teardown do
+      Assert.suite.send(:teardowns).reject!{|b| b == @teardown_block }
     end
     subject{ @teardown_blocks }
 
     should "add the block to the suite's collection of teardown blocks" do
-      assert_includes subject, @teardown_block
-    end
-
-    teardown do
-      Assert.suite.teardown_blocks.reject!{|b| b == @teardown_block }
+      assert_includes @teardown_block, subject
     end
 
   end
@@ -77,95 +67,85 @@ class Assert::Context::ClassMethodsTest < Assert::Context
   class SetupTest < ClassMethodsTest
     desc "setup method"
     setup do
-      setup_block = @setup_block = lambda{ @something = true }
+      setup_block = @setup_block = ::Proc.new{ @something = true }
       @context_class = Factory.context_class do
         setup(&setup_block)
       end
-      @setup_blocks = @context_class.setup_blocks
+      @setup_blocks = @context_class.send(:setups)
     end
     subject{ @setup_blocks }
 
     should "add the block to the context's collection of setup blocks" do
-      assert_includes subject, @setup_block
-    end
-    should "raise an ArgumentError when no block is passed" do
-      assert_raises ArgumentError do
-        @context_class.setup
-      end
+      assert_includes @setup_block, subject
     end
 
   end
 
 
 
-  class TeardownTest < ClassMethodsTest
-    desc "teardown method"
+  class MultipleSetupsTest < ClassMethodsTest
+    desc "a context class with multiple setups"
     setup do
-      teardown_block = @teardown_block = lambda{ @something = false }
-      @context_class = Factory.context_class do
-        teardown(&teardown_block)
+      @object = (Class.new{ attr_accessor :status }).new
+      setup_block = @setup_block = ::Proc.new{ self.status = "the setup" }
+      @parent_class = Factory.context_class do
+        setup(&setup_block)
+      end
+      setup_block = @setup_block = ::Proc.new{ self.status += " has been run" }
+      @context_class = Factory.context_class(@parent_class) do
+        setup(&setup_block)
       end
-      @teardown_blocks = @context_class.teardown_blocks
+      @context_class.setup(@object)
+      @expected = "the setup has been run"
     end
-    subject{ @teardown_blocks }
+    subject{ @object }
 
-    should "add the block to the context's collection of teardown blocks" do
-      assert_includes subject, @teardown_block
-    end
-    should "raise an ArgumentError when no block is passed" do
-      assert_raises ArgumentError do
-        @context_class.teardown
-      end
+    should "run it's parent and it's own setup blocks in the correct order" do
+      assert_equal @expected, subject.status
     end
 
   end
 
 
 
-  class AllSetupBlocksTest < ClassMethodsTest
-    desc "all_setup_blocks method"
+  class TeardownTest < ClassMethodsTest
+    desc "teardown method"
     setup do
-      parent_block = @parent_block = lambda{ @parent_something = true }
-      @parent_class = Factory.context_class do
-        setup(&parent_block)
-      end
-      setup_block = @setup_block = lambda{ @something = true }
-      @context_class = Factory.context_class(@parent_class) do
-        setup(&setup_block)
+      teardown_block = @teardown_block = ::Proc.new{ @something = false }
+      @context_class = Factory.context_class do
+        teardown(&teardown_block)
       end
-      @setup_blocks = @context_class.all_setup_blocks
+      @teardown_blocks = @context_class.send(:teardowns)
     end
-    subject{ @setup_blocks }
+    subject{ @teardown_blocks }
 
-    should "return a collection containing both context's setup blocks" do
-      assert_kind_of Array, subject
-      assert_includes subject, @parent_block
-      assert_includes subject, @setup_block
+    should "add the block to the context's collection of teardown blocks" do
+      assert_includes @teardown_block, subject
     end
 
   end
 
 
 
-  class AllTeardownBlocksTest < ClassMethodsTest
-    desc "all_teardown_blocks method"
+  class MultipleTeardownsTest < ClassMethodsTest
+    desc "a context class with multiple teardowns"
     setup do
-      parent_block = @parent_block = lambda{ @parent_something = false }
+      @object = (Class.new{ attr_accessor :status }).new
+      teardown_block = @teardown_block = ::Proc.new{ self.status += " has been run" }
       @parent_class = Factory.context_class do
-        teardown(&parent_block)
+        teardown(&teardown_block)
       end
-      teardown_block = @teardown_block = lambda{ @something = false }
+      teardown_block = @teardown_block = ::Proc.new{ self.status = "the teardown" }
       @context_class = Factory.context_class(@parent_class) do
         teardown(&teardown_block)
       end
-      @teardown_blocks = @context_class.all_teardown_blocks
+      @context_class.teardown(@object)
+      @expected = "the teardown has been run"
     end
-    subject{ @teardown_blocks }
+    subject{ @object }
 
-    should "return a collection containing both context's setup blocks" do
-      assert_kind_of Array, subject
-      assert_includes subject, @parent_block
-      assert_includes subject, @teardown_block
+    should "run it's parent and it's own teardown blocks in the correct order" do
+      assert_equal @expected, subject.status
     end
 
   end
@@ -173,7 +153,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
 
 
   class DescTest < ClassMethodsTest
-    desc "desc method"
+    desc "desc method with an arg"
     setup do
       descs = @descs = [ "something amazing", "it really is" ]
       @context_class = Factory.context_class do
@@ -181,19 +161,13 @@ class Assert::Context::ClassMethodsTest < Assert::Context
           desc text
         end
       end
-      @descriptions = @context_class.descriptions
     end
-    subject{ @descriptions }
+    subject{ @context_class.send(:descriptions) }
 
     should "return a collection containing any descriptions defined on the class" do
       assert_kind_of Array, subject
       @descs.each do |text|
-        assert_includes subject, text
-      end
-    end
-    should "raise an error when no description is provided" do
-      assert_raises ArgumentError do
-        @context_class.desc
+        assert_includes text, subject
       end
     end
 
@@ -202,7 +176,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
 
 
   class FullDescriptionTest < ClassMethodsTest
-    desc "full_description method"
+    desc "description method without an arg"
     setup do
       parent_text = @parent_desc = "parent description"
       @parent_class = Factory.context_class do
@@ -212,7 +186,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
       @context_class = Factory.context_class(@parent_class) do
         desc text
       end
-      @full_description = @context_class.full_description
+      @full_description = @context_class.description
     end
     subject{ @full_description }
 
@@ -226,10 +200,10 @@ class Assert::Context::ClassMethodsTest < Assert::Context
 
 
 
-  class SubjectTest < ClassMethodsTest
-    desc "subject method"
+  class SubjectFromLocalTest < ClassMethodsTest
+    desc "subject method using local context"
     setup do
-      subject_block = @subject_block = lambda{ @something }
+      subject_block = @subject_block = ::Proc.new{ @something }
       @context_class = Factory.context_class do
         subject(&subject_block)
       end
@@ -237,22 +211,17 @@ class Assert::Context::ClassMethodsTest < Assert::Context
     subject{ @subject_block }
 
     should "set the subject block on the context class" do
-      assert_equal subject, @context_class.subject_block
-    end
-    should "raise an ArgumentError when no block is passed" do
-      assert_raises ArgumentError do
-        @context_class.subject
-      end
+      assert_equal @context_class.subject, subject
     end
 
   end
 
 
 
-  class SubjectBlockTest < ClassMethodsTest
-    desc "subject_block method"
+  class SubjectFromParentTest < ClassMethodsTest
+    desc "subject method using parent context"
     setup do
-      parent_block = @parent_block = lambda{ @something }
+      parent_block = @parent_block = ::Proc.new{ @something }
       @parent_class = Factory.context_class do
         subject(&parent_block)
       end
@@ -261,7 +230,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
     subject{ @parent_block }
 
     should "default to it's parents subject block" do
-      assert_equal subject, @context_class.subject_block
+      assert_equal subject, @context_class.subject
     end
   end
 
@@ -271,7 +240,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
     desc "should method"
     setup do
       should_desc = "be true"
-      should_block = @should_block = lambda{ assert(true) }
+      should_block = @should_block = ::Proc.new{ assert(true) }
       @context_class = Factory.context_class do
         should(should_desc, &should_block)
       end
@@ -281,7 +250,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
     subject{ @context }
 
     should "define a test method named after the should desc" do
-      assert_respond_to subject, @method_name
+      assert_respond_to @method_name, subject
       assert_equal subject.instance_eval(&@should_block), subject.send(@method_name)
     end
 
@@ -293,7 +262,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
     desc "should_eventually method"
     setup do
       should_desc = @should_desc = "be true"
-      should_block = @should_block = lambda{ assert(true) }
+      should_block = @should_block = ::Proc.new{ assert(true) }
       @context_class = Factory.context_class do
         should_eventually(should_desc, &should_block)
       end
@@ -303,7 +272,7 @@ class Assert::Context::ClassMethodsTest < Assert::Context
     subject{ @context }
 
     should "define a test method named after the should desc that raises a test skipped" do
-      assert_respond_to subject, @method_name
+      assert_respond_to @method_name, subject
       assert_raises(Assert::Result::TestSkipped) do
         subject.send(@method_name)
       end

data/test/context_test.rb

@@ -1,27 +1,23 @@
 require 'assert'
 
-class Assert::Context::BasicTest < Assert::Context
-  desc "Assert context"
-  setup do
-    @test = Factory.test
-    @context_class = @test.context_class
-    @context = @context_class.new(@test)
-  end
-  subject{ @context }
+class Assert::Context
 
-  INSTANCE_METHODS = [
-    :assert, :assert_not, :refute,
-    :skip, :pass, :fail, :flunk, :ignore,
-    :subject
-  ]
-  INSTANCE_METHODS.each do |method|
-    should "respond to the instance method ##{method}" do
-      assert_respond_to subject, method
+  class BasicTest < Assert::Context
+    desc "Assert context"
+    setup do
+      @test = Factory.test
+      @context_class = @test.context_class
+      @context = @context_class.new(@test)
     end
-  end
+    teardown do
+      TEST_ASSERT_SUITE.clear
+    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
 
-  teardown do
-    TEST_ASSERT_SUITE.clear
   end
 
 
@@ -104,31 +100,30 @@ class Assert::Context::BasicTest < Assert::Context
       assert_kind_of Array, subject.backtrace
       assert_match /assert\/test\/context_test\.rb/, subject.trace
     end
+  end
 
-    class StringMessageTest < FailTest
-      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
-      end
+  class StringMessageTest < FailTest
+    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
     end
 
-    class ProcMessageTest < FailTest
-      desc "with a proc message"
-      setup do
-        @fail_msg = lambda{ "Still didn't work" }
-        @result = @context.fail(@fail_msg)
-      end
+  end
 
-      should "set the message passed to it on the result" do
-        assert_equal @fail_msg.call, subject.message
-      end
+  class ProcMessageTest < FailTest
+    desc "with a proc message"
+    setup do
+      @fail_msg = ::Proc.new{ "Still didn't work" }
+      @result = @context.fail(@fail_msg)
+    end
 
+    should "set the message passed to it on the result" do
+      assert_equal @fail_msg.call, subject.message
     end
 
   end
@@ -184,7 +179,7 @@ class Assert::Context::BasicTest < Assert::Context
 
       should "return a fail result" do
         assert_kind_of Assert::Result::Fail, subject
-        assert_equal "#{@what_failed}\n#{@fail_desc}", subject.message
+        assert_equal [@fail_desc, @what_failed].join("\n"), subject.message
       end
 
     end
@@ -219,7 +214,7 @@ class Assert::Context::BasicTest < Assert::Context
 
       should "return a fail result" do
         assert_kind_of Assert::Result::Fail, subject
-        assert_equal "#{@what_failed}\n#{@fail_desc}", subject.message
+        assert_equal [@fail_desc, @what_failed].join("\n"), subject.message
       end
 
     end