assert 0.1.0

data/test/assertions/assert_raises_test.rb

@@ -0,0 +1,49 @@
+require 'assert'
+
+class Assert::Assertions::AssertRaisesTest < Assert::Context
+  desc "the assert_raises helper run in a test"
+  setup do
+    fail_desc = @fail_desc = "assert raises fail desc"
+    @test = Factory.test do
+      assert_raises(StandardError, RuntimeError){ raise(StandardError) }          # pass
+      assert_raises(StandardError, RuntimeError, fail_desc){ raise(Exception) }   # fail
+      assert_raises(RuntimeError, fail_desc){ raise(StandardError) }              # fail
+      assert_raises(RuntimeError, fail_desc){ true }                              # fail
+      assert_raises(fail_desc){ true }                                            # fail
+    end
+    @test.run
+  end
+  subject{ @test }
+
+  should "have 3 total results" do
+    assert_equal 5, subject.result_count
+  end
+  should "have 1 pass result" do
+    assert_equal 1, subject.result_count(:pass)
+  end
+  should "have 4 fail results" do
+    assert_equal 4, subject.result_count(:fail)
+  end
+
+  class FailMessageTest < AssertRaisesTest
+    desc "with a failed result"
+    setup do
+      @expected = [
+        "#{@fail_desc}\nStandardError or RuntimeError exception expected, not:",
+        "#{@fail_desc}\nRuntimeError exception expected, not:",
+        "#{@fail_desc}\nRuntimeError exception expected but nothing was raised.",
+        "#{@fail_desc}\nAn exception expected but nothing was raised."
+      ]
+      @fail_messages = @test.fail_results.collect(&:message)
+    end
+    subject{ @fail_messages }
+
+    should "have a fail message with an explanation of what failed and my fail description" do
+      subject.each_with_index do |message, n|
+        assert_match /^#{@expected[n]}/, message
+      end
+    end
+
+  end
+
+end

data/test/assertions/assert_respond_to_test.rb

@@ -0,0 +1,43 @@
+require 'assert'
+
+class Assert::Assertions::AssertRespondToTest < Assert::Context
+  desc "the assert_respond_to helper run in a test"
+  setup do
+    fail_desc = @fail_desc = "assert respond to fail desc"
+    fail_args = @fail_args = [ "1", :abs, fail_desc ]
+    @test = Factory.test do
+      assert_respond_to(1, :abs)      # pass
+      assert_respond_to(*fail_args)   # fail
+    end
+    @test.run
+  end
+  subject{ @test }
+
+  should "have 2 total results" do
+    assert_equal 2, subject.result_count
+  end
+  should "have 1 pass result" do
+    assert_equal 1, subject.result_count(:pass)
+  end
+  should "have 1 fail result" do
+    assert_equal 1, subject.result_count(:fail)
+  end
+
+  class FailMessageTest < AssertRespondToTest
+    desc "with a failed result"
+    setup do
+      @expected = [
+        "Expected #{@fail_args[0].inspect} (#{@fail_args[0].class}) to",
+        "respond to ##{@fail_args[1]}.\n#{@fail_args[2]}"
+      ].join(" ")
+      @fail_message = @test.fail_results.first.message
+    end
+    subject{ @fail_message }
+
+    should "have a fail message with an explanation of what failed and my fail description" do
+      assert_equal @expected, subject
+    end
+
+  end
+
+end

data/test/assertions_test.rb

@@ -0,0 +1,334 @@
+require 'assert'
+
+class Assert::Assertions::BasicTest < Assert::Context
+
+  desc "An assert context"
+  setup do
+    @context_class = Factory.context_class
+    @context = @context_class.new
+  end
+  subject{ @context }
+
+  INSTANCE_METHODS = [
+    :assert_block, :assert_not_block, :refute_block,
+    :assert_raises, :assert_raise, :assert_nothing_raised, :assert_not_raises, :assert_not_raise,
+    :assert_kind_of, :assert_not_kind_of, :refute_kind_of,
+    :assert_instance_of, :assert_not_instance_of, :refute_instance_of,
+    :assert_respond_to, :assert_not_respond_to, :refute_respond_to,
+    :assert_same, :assert_not_same, :refute_same,
+    :assert_equal, :assert_not_equal, :refute_equal,
+    :assert_match, :assert_not_match, :assert_no_match, :refute_match
+  ]
+  INSTANCE_METHODS.each do |method|
+    should "respond to the instance method ##{method}" do
+      assert_respond_to subject, method
+    end
+  end
+
+  class IgnoredTest < BasicTest
+    desc "ignored assertions helpers"
+    setup do
+      @tests = Assert::Assertions::IGNORED_ASSERTION_HELPERS.collect do |helper|
+        Factory.test("ignored assertion helper #{helper}", @context_class) do
+          self.send(helper, "doesn't matter")
+        end
+      end
+      @expected_messages = Assert::Assertions::IGNORED_ASSERTION_HELPERS.collect do |helper|
+        [ "The assertion helper '#{helper}' is not supported. Please use ",
+          "another helper or the basic assert."
+        ].join
+      end
+      @results = @tests.collect(&:run).flatten
+    end
+    subject{ @results }
+
+    should "have an ignored result for each helper in the constant" do
+      subject.each do |result|
+        assert_kind_of Assert::Result::Ignore, result
+      end
+      assert_equal(Assert::Assertions::IGNORED_ASSERTION_HELPERS.size, subject.size)
+    end
+    should "have a custom ignore message for each helper in the constant" do
+      assert_equal(@expected_messages, subject.collect(&:message))
+    end
+
+  end
+
+end
+
+=begin
+module Assert::Assertions
+
+  class AssertSameTest < BasicTest
+
+    setup do
+      klass = Class.new
+      object = klass.new
+      @test = Assert::Test.new("assert same test", lambda do
+        assert_same(object, object)     # pass
+        assert_same(object, klass.new)  # fail
+      end, @context_klass)
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    class MessagesTest < AssertSameTest
+
+      setup do
+        klass = Class.new
+        args = [ klass.new, klass.new, "assert same shoudn't fail!" ]
+        @test = Assert::Test.new("assert same message test", lambda do
+          assert_same(*args)
+        end, @context_klass)
+        @expected_message = "Expected #{args[0].inspect} (#{args[0].object_id}) to be the same as #{args[1]} (#{args[1].object_id}).\n#{args[2]}"
+        @test.run
+        @message = @test.fail_results.first.message
+      end
+      subject{ @message }
+
+      should "have the correct failure message" do
+        assert_equal @expected_message, subject
+      end
+
+    end
+
+  end
+
+  class AssertNotSameTest < BasicTest
+
+    setup do
+      klass = Class.new
+      object = klass.new
+      @test = Assert::Test.new("assert not same test", lambda do
+        assert_not_same(object, object)     # fail
+        assert_not_same(object, klass.new)  # pass
+      end, @context_klass)
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    class MessagesTest < AssertNotSameTest
+
+      setup do
+        klass = Class.new
+        object = klass.new
+        args = [ object, object, "assert not same shoudn't fail!" ]
+        @test = Assert::Test.new("assert not same message test", lambda do
+          assert_not_same(*args)
+        end, @context_klass)
+        @expected_message = "#{args[0].inspect} (#{args[0].object_id}) not expected to be the same as #{args[1]} (#{args[1].object_id}).\n#{args[2]}"
+        @test.run
+        @message = @test.fail_results.first.message
+      end
+      subject{ @message }
+
+      should "have the correct failure message" do
+        assert_equal @expected_message, subject
+      end
+
+    end
+
+  end
+
+  class AssertEqualTest < BasicTest
+
+    setup do
+      @test = Assert::Test.new("assert equal test", lambda do
+        assert_equal(1, 1)  # pass
+        assert_equal(1, 2)  # fail
+      end, @context_klass)
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    class MessagesTest < AssertEqualTest
+
+      setup do
+        args = [ 1, 2, "assert equal shoudn't fail!" ]
+        @test = Assert::Test.new("assert equal message test", lambda do
+          assert_equal(*args)
+        end, @context_klass)
+        @expected_message = "Expected #{args[0].inspect}, not #{args[1].inspect}.\n#{args[2]}"
+        @test.run
+        @message = @test.fail_results.first.message
+      end
+      subject{ @message }
+
+      should "have the correct failure message" do
+        assert_equal @expected_message, subject
+      end
+
+    end
+
+  end
+
+  class AssertNotEqualTest < BasicTest
+
+    setup do
+      @test = Assert::Test.new("assert not equal test", lambda do
+        assert_not_equal(1, 1)  # fail
+        assert_not_equal(1, 2)  # pass
+      end, @context_klass)
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    class MessagesTest < AssertNotEqualTest
+
+      setup do
+        args = [ 1, 1, "assert not equal shoudn't fail!" ]
+        @test = Assert::Test.new("assert not equal message test", lambda do
+          assert_not_equal(*args)
+        end, @context_klass)
+        @expected_message = "#{args[0].inspect} not expected to be equal to #{args[1].inspect}.\n#{args[2]}"
+        @test.run
+        @message = @test.fail_results.first.message
+      end
+      subject{ @message }
+
+      should "have the correct failure message" do
+        assert_equal @expected_message, subject
+      end
+
+    end
+
+  end
+
+  class AssertMatchTest < BasicTest
+
+    setup do
+      @test = Assert::Test.new("assert match test", lambda do
+        assert_match("a string", /a/)     # pass
+        assert_match("a string", "not")   # fail
+      end, @context_klass)
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    class MessagesTest < AssertMatchTest
+
+      setup do
+        args = [ "a string", "not", "assert match shoudn't fail!" ]
+        @test = Assert::Test.new("assert match message test", lambda do
+          assert_match(*args)
+        end, @context_klass)
+        @expected_message = "Expected #{args[0].inspect} to match #{args[1].inspect}.\n#{args[2]}"
+        @test.run
+        @message = @test.fail_results.first.message
+      end
+      subject{ @message }
+
+      should "have the correct failure message" do
+        assert_equal @expected_message, subject
+      end
+
+    end
+
+  end
+
+  class AssertNotMatchTest < BasicTest
+
+    setup do
+      @test = Assert::Test.new("assert not match test", lambda do
+        assert_not_match("a string", /a/)     # fail
+        assert_not_match("a string", "not")   # pass
+      end, @context_klass)
+      @test.run
+    end
+    subject{ @test }
+
+    should "have 2 total results" do
+      assert_equal 2, subject.result_count
+    end
+
+    should "have 1 pass result" do
+      assert_equal 1, subject.result_count(:pass)
+    end
+
+    should "have 1 fail result" do
+      assert_equal 1, subject.result_count(:fail)
+    end
+
+    class MessagesTest < AssertNotMatchTest
+
+      setup do
+        args = [ "a string", /a/, "assert not match shoudn't fail!" ]
+        @test = Assert::Test.new("assert not match message test", lambda do
+          assert_not_match(*args)
+        end, @context_klass)
+        @expected_message = "#{args[0].inspect} not expected to match #{args[1].inspect}.\n#{args[2]}"
+        @test.run
+        @message = @test.fail_results.first.message
+      end
+      subject{ @message }
+
+      should "have the correct failure message" do
+        assert_equal @expected_message, subject
+      end
+
+    end
+
+  end
+
+end
+=end

data/test/context/class_methods_test.rb

@@ -0,0 +1,314 @@
+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
+    end
+  end
+
+  teardown do
+    TEST_ASSERT_SUITE.clear
+  end
+
+
+
+  class SetupOnceTest < ClassMethodsTest
+    desc "setup_once method"
+    setup do
+      setup_block = @setup_block = lambda{ something_once = true }
+      @context_class = Factory.context_class do
+        setup_once(&setup_block)
+      end
+      @setup_blocks = Assert.suite.setup_blocks
+    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 }
+    end
+
+  end
+
+
+
+  class TeardownOnceTest < ClassMethodsTest
+    desc "teardown_once method"
+    setup do
+      teardown_block = @teardown_block = lambda{ something_once = true }
+      @context_class = Factory.context_class do
+        teardown_once(&teardown_block)
+      end
+      @teardown_blocks = Assert.suite.teardown_blocks
+    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 }
+    end
+
+  end
+
+
+
+  class SetupTest < ClassMethodsTest
+    desc "setup method"
+    setup do
+      setup_block = @setup_block = lambda{ @something = true }
+      @context_class = Factory.context_class do
+        setup(&setup_block)
+      end
+      @setup_blocks = @context_class.setup_blocks
+    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
+    end
+
+  end
+
+
+
+  class TeardownTest < ClassMethodsTest
+    desc "teardown method"
+    setup do
+      teardown_block = @teardown_block = lambda{ @something = false }
+      @context_class = Factory.context_class do
+        teardown(&teardown_block)
+      end
+      @teardown_blocks = @context_class.teardown_blocks
+    end
+    subject{ @teardown_blocks }
+
+    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
+    end
+
+  end
+
+
+
+  class AllSetupBlocksTest < ClassMethodsTest
+    desc "all_setup_blocks 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)
+      end
+      @setup_blocks = @context_class.all_setup_blocks
+    end
+    subject{ @setup_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
+    end
+
+  end
+
+
+
+  class AllTeardownBlocksTest < ClassMethodsTest
+    desc "all_teardown_blocks method"
+    setup do
+      parent_block = @parent_block = lambda{ @parent_something = false }
+      @parent_class = Factory.context_class do
+        teardown(&parent_block)
+      end
+      teardown_block = @teardown_block = lambda{ @something = false }
+      @context_class = Factory.context_class(@parent_class) do
+        teardown(&teardown_block)
+      end
+      @teardown_blocks = @context_class.all_teardown_blocks
+    end
+    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, @teardown_block
+    end
+
+  end
+
+
+
+  class DescTest < ClassMethodsTest
+    desc "desc method"
+    setup do
+      descs = @descs = [ "something amazing", "it really is" ]
+      @context_class = Factory.context_class do
+        descs.each do |text|
+          desc text
+        end
+      end
+      @descriptions = @context_class.descriptions
+    end
+    subject{ @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
+      end
+    end
+
+  end
+
+
+
+  class FullDescriptionTest < ClassMethodsTest
+    desc "full_description method"
+    setup do
+      parent_text = @parent_desc = "parent description"
+      @parent_class = Factory.context_class do
+        desc parent_text
+      end
+      text = @desc = "and the description for this context"
+      @context_class = Factory.context_class(@parent_class) do
+        desc text
+      end
+      @full_description = @context_class.full_description
+    end
+    subject{ @full_description }
+
+    should "return a string of all the inherited descriptions" do
+      assert_kind_of String, subject
+      assert_match @parent_desc, subject
+      assert_match @desc, subject
+    end
+
+  end
+
+
+
+  class SubjectTest < ClassMethodsTest
+    desc "subject method"
+    setup do
+      subject_block = @subject_block = lambda{ @something }
+      @context_class = Factory.context_class do
+        subject(&subject_block)
+      end
+    end
+    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
+    end
+
+  end
+
+
+
+  class SubjectBlockTest < ClassMethodsTest
+    desc "subject_block method"
+    setup do
+      parent_block = @parent_block = lambda{ @something }
+      @parent_class = Factory.context_class do
+        subject(&parent_block)
+      end
+      @context_class = Factory.context_class(@parent_class)
+    end
+    subject{ @parent_block }
+
+    should "default to it's parents subject block" do
+      assert_equal subject, @context_class.subject_block
+    end
+  end
+
+
+
+  class ShouldTest < ClassMethodsTest
+    desc "should method"
+    setup do
+      should_desc = "be true"
+      should_block = @should_block = lambda{ assert(true) }
+      @context_class = Factory.context_class do
+        should(should_desc, &should_block)
+      end
+      @method_name = "test: should #{should_desc}"
+      @context = @context_class.new(Factory.test("something", @context_class))
+    end
+    subject{ @context }
+
+    should "define a test method named after the should desc" do
+      assert_respond_to subject, @method_name
+      assert_equal subject.instance_eval(&@should_block), subject.send(@method_name)
+    end
+
+  end
+
+
+
+  class ShouldEventuallyTest < ClassMethodsTest
+    desc "should_eventually method"
+    setup do
+      should_desc = @should_desc = "be true"
+      should_block = @should_block = lambda{ assert(true) }
+      @context_class = Factory.context_class do
+        should_eventually(should_desc, &should_block)
+      end
+      @method_name = "test: should #{@should_desc}"
+      @context = @context_class.new(Factory.test("something", @context_class))
+    end
+    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_raises(Assert::Result::TestSkipped) do
+        subject.send(@method_name)
+      end
+    end
+
+  end
+
+end