assertions-eb 1.7.2

data/lib/assertions.rb

@@ -0,0 +1,376 @@
+#!/usr/bin/env ruby
+module Test
+  module Unit
+
+    #
+    # Some useful extra assertions.
+    # Require 'assertions', and Test::Unit::Assertions will have
+    # the additional assertions.
+    #
+    module Assertions
+      public
+
+      #
+      # ====Description:
+      # This assertion passes if and only if block contains an assertion
+      # that fails (but which is suppressed from propagating outside of
+      # block and so will not cause the test to fail).
+      # If the assertion passes, the failed assertion is written to
+      # stdout.  This method is (only?) useful when testing other assertions.
+      #
+      # ====Example:
+      #  assert_fail do
+      #    assert_equal(5, 4)
+      #  end
+      #
+      # ====Parameters:
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      # [&block]
+      #      This block should contain an assertion that fails.
+      #
+      def assert_fail(message = "", &block)
+        full_message = build_message(message,
+                                     "Failed assertion was expected, but it did not occur.")
+
+        assert_block(full_message) do
+          begin
+            yield
+            false
+          rescue AssertionFailedError => e
+            true
+          end
+        end
+      end
+
+      #
+      # ====Description:
+      # This assertion passes if and only if boolean is false or nil.
+      #
+      # ====Parameters:
+      # [boolean]
+      #      This must be false or nil or the assertion to pass
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_not(boolean, message = "")
+        full_message = build_message(message,
+                                     "<?> incorrectly is true.",
+                                     boolean)
+        assert_block(full_message) do
+          !boolean
+        end
+      end
+
+      #
+      # ====Description:
+      # This is a convenience wrapper around assert_operator.  It asserts that
+      # the value is greater than zero
+      #
+      # ====Example:
+      #  assert_positive(12)
+      #
+      # ====Parameters:
+      # [value]
+      #      The number whose positiveness we wish to determine
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_positive(value, message = "")
+        assert_operator(value, :>, 0, message)
+      end
+
+      #
+      # ====Description:
+      # This is a convenience wrapper around assert_operator.  It asserts that
+      # the value is less than zero
+      #
+      # ====Example:
+      #  assert_negative(-5)
+      #
+      # ====Parameters:
+      # [value]
+      #      The number whose negativeness we wish to determine
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_negative(value, message = "")
+        assert_operator(value, :<, 0, message)
+      end
+
+      #
+      # ====Description:
+      # This is a convenience wrapper around assert_operator.  It asserts that
+      # lhs > rhs.
+      #
+      # ====Example:
+      #  assert_greater_than(5, 4)
+      #
+      # ====Parameters:
+      # [lhs]
+      #      The left-hand side of the comparison.
+      # [rhs]
+      #      The right-hand side of the comparison.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_greater_than(lhs, rhs, message = "")
+        assert_operator(lhs, :>, rhs, message)
+      end
+      alias assert_gt assert_greater_than
+
+      #
+      # ====Description:
+      # This is a convenience wrapper around assert_operator.  It asserts that
+      # lhs >= rhs.
+      #
+      # ====Example:
+      #  assert_greater_than_or_equal_to(5, 5)
+      #
+      # ====Parameters:
+      # [lhs]
+      #      The left-hand side of the comparison.
+      # [rhs]
+      #      The right-hand side of the comparison.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_greater_than_or_equal_to(lhs, rhs, message = "")
+        assert_operator(lhs, :>=, rhs, message)
+      end
+      alias assert_ge assert_greater_than_or_equal_to
+
+      #
+      # ====Description:
+      # Will tell you if the elements in an Enum are sorted (ascending)
+      #
+      # ====Example:
+      #  assert_sorted([1,2,3,4])
+      #
+      # ====Parameters:
+      # [enum]
+      #      The enumeration to check for sortedness.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      def assert_sorted(enum, message = "")
+        raise ArgumentError.new("enum must be enumerable") unless enum.is_a?(Enumerable)
+        assert_equal enum.clone.sort{|a,b| a <=> b }, enum
+      end
+
+      #
+      # ====Description:
+      # Will tell you if the elements in an Enum are sorted (ascending)
+      #
+      # ====Example:
+      #  assert_sorted_desc([4,3,2,1])
+      #
+      # ====Parameters:
+      # [enum]
+      #      The enumeration to check for sortedness.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      def assert_sorted_desc(enum, message = "")
+        raise ArgumentError.new("enum must be enumerable") unless enum.is_a?(Enumerable)
+        assert_equal enum.clone.sort{|a,b| b <=> a }, enum
+      end
+
+
+      private
+      def check_enum_for_key_sortability(key, enum)
+        raise ArgumentError.new("key must be symbol or string") unless (key.is_a?(String) || key.is_a?(Symbol))
+        raise ArgumentError.new("enum must be enumerable") unless enum.is_a?(Enumerable)
+        raise ArgumentError.new("enum's elements don't respond to the key") unless enum.all?{ |x| (x.is_a?(Hash) && x.has_key?(key)) || x.respond_to?(key) }
+      end
+
+      public
+      #
+      # ====Description:
+      # Will tell you if the elements in an Enum are sorted (ascending)
+      # based on a key corresponding to a key in a hash or method on a
+      # class.
+      #
+      # ====Example:
+      #  assert_sorted_by :bar, [{:bar => 1}, {:bar => 2}]
+      #
+      # ====Parameters:
+      # [key]
+      #      A string or symbol to use to get a value on an object in 'enum'
+      # [enum]
+      #      The enumeration to check for sortedness.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      def assert_sorted_by(key, enum, message = "")
+        check_enum_for_key_sortability(key, enum)
+        assert_sorted enum.map{ |x| x.is_a?(Hash) ? x[key] : x.send(key) }
+      end
+
+      #
+      # ====Description:
+      # Will tell you if the elements in an Enum are sorted (descending)
+      # based on a key corresponding to a key in a hash or method on a
+      # class.
+      #
+      # ====Example:
+      #  assert_sorted_by_desc :bar, [{:bar => 2}, {:bar => 1}]
+      #
+      # ====Parameters:
+      # [key]
+      #      A string or symbol to use to get a value on an object in 'enum'
+      # [enum]
+      #      The enumeration to check for sortedness.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      def assert_sorted_by_desc(key, enum, message = "")
+        check_enum_for_key_sortability(key, enum)
+        assert_sorted_desc enum.map{ |x| x.is_a?(Hash) ? x[key] : x.send(key) }
+      end
+
+      #
+      # ====Description:
+      # Find out if a something is between two other things when compared.
+      # It asserts that lhs1 < rhs < lhs2 or lhs1 > rhs > lhs2
+      #
+      # ====Example:
+      #  assert_between(Date.yesterday, Date.tomorrow, Date.today)
+      #
+      # ====Parameters:
+      # [lhs1]
+      #      One of the things to compare against
+      # [lhs2]
+      #      The other thing to compare against
+      # [rhs]
+      #      The thing being tested for between-ness
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_between(lhs1, lhs2, rhs, message="")
+        if lhs1 == lhs2
+          full_message = build_message(message, "Gave the same value for both sides of range. <?> was not equal to <?>", rhs, lhs1)
+
+          assert_block(full_message) { lhs1 == rhs }
+        else
+          lower  = lhs1 < lhs2 ? lhs1 : lhs2
+          higher = lhs1 < lhs2 ? lhs2 : lhs1
+          full_message = build_message(message, "<?> was not between <?> and <?>", rhs, lower, higher)
+          assert_block(full_message) { lower < rhs && rhs < higher }
+        end
+      end
+
+      #
+      # ====Description:
+      # This is a convenience wrapper around assert_operator.  It asserts that
+      # lhs < rhs.
+      #
+      # ====Example:
+      #  assert_less_than(4, 5)
+      #
+      # ====Parameters:
+      # [lhs]
+      #      The left-hand side of the comparison.
+      # [rhs]
+      #      The right-hand side of the comparison.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_less_than(lhs, rhs, message = "")\
+        assert_operator(lhs, :<, rhs, message)
+      end
+      alias assert_lt assert_less_than
+
+      #
+      # ====Description:
+      # This is a convenience wrapper around assert_operator.  It asserts that
+      # lhs <= rhs.
+      #
+      # ====Example:
+      #  assert_less_than_or_equal_to(4, 4)
+      #
+      # ====Parameters:
+      # [lhs]
+      #      The left-hand side of the comparison.
+      # [rhs]
+      #      The right-hand side of the comparison.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      #
+      def assert_less_than_or_equal_to(lhs, rhs, message = "")
+        assert_operator(lhs, :<=, rhs, message)
+      end
+      alias assert_le assert_less_than_or_equal_to
+
+      #
+      # ====Description:
+      # This assertion passes if and only if block throws an exception of
+      # class (or descended from class) expected_exception_class with
+      # message expected_exception_message.
+      #
+      # ====Example:
+      #  assert_raise_message("Hello, exception!", RuntimeError) do
+      #    raise "Hello, exception!"
+      #  end
+      #
+      # ====Parameters:
+      # [expected_exception_message]
+      #      The message expected to be contained in the exception thrown
+      #      by block.
+      # [expected_exception_class]
+      #      The expected class (or parent class) of the exception thrown by
+      #      block.
+      # [message = ""]
+      #      An optional additional message that will be displayed if the
+      #      assertion fails.
+      # [&block]
+      #      The block that is supposed to throw the specified exception.
+      #
+      def assert_raise_message(expected_exception_message,
+                               expected_exception_class,
+                               message = "",
+                               &block)
+        full_message = build_message(message,
+                                     "<?> exception expected but none was thrown.",
+                                     expected_exception_class)
+        actual_exception = nil
+        assert_block(full_message) do
+          begin
+            yield
+            false
+          rescue Exception => e
+            actual_exception = e
+            true
+          end
+        end
+
+        full_message = build_message(message,
+                                     "<?> exception expected but was\n?",
+                                     expected_exception_class,
+                                     actual_exception)
+
+        assert_block(full_message) do
+          actual_exception.is_a?(expected_exception_class)
+        end
+
+        full_message = build_message(message,
+                                     "<?> exception message expected but was\n<?>",
+                                     expected_exception_message,
+                                     actual_exception.message)
+        assert_block(full_message) do
+          expected_exception_message == actual_exception.message
+        end
+      end
+
+    end
+  end
+end

data/test/assert_between_test.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require File.expand_path("../test_helper", __FILE__)
+
+class AssertBetweenTest < Test::Unit::TestCase
+  def test_assert_between_4_4_5_fails
+    assert_raise_message("Gave the same value for both sides of range. <5> was not equal to <4>",
+                         Test::Unit::AssertionFailedError) do
+      assert_between 4, 4, 5
+    end
+  end
+
+  def test_assert_between_3_2_5_fails
+    assert_raise_message("<5> was not between <2> and <3>", Test::Unit::AssertionFailedError) do
+      assert_between 3, 2, 5
+    end
+  end
+
+  def test_assert_between_4_8_6_succeeds
+    assert_between 4, 8, 6
+  end
+
+  def test_assert_between_8_4_6_succeeds
+    assert_between 8, 4, 6
+  end
+
+  def test_assert_between_on_now_between_past_and_future_times_succeeds
+    now = Time.now
+    before = now - 1
+    after = now + 1
+    assert_between before, after, now
+  end
+
+  def test_assert_between_on_now_between_future_and_past_times_succeeds
+    now = Time.now
+    before = now - 1
+    after = now + 1
+    assert_between after, before, now
+  end
+
+  def test_assert_between_on_before_time_between_now_and_future_times_succeeds
+    now = Time.now
+    before = now - 1
+    after = now + 1
+    assert_raises(Test::Unit::AssertionFailedError) { assert_between after, now, before }
+  end
+end

data/test/assert_fail_test.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertFailTest < Test::Unit::TestCase
+  def test_assert_fail_fails_if_the_block_has_no_failed_assertions
+    failed_assertion = false
+    begin
+      assert_fail do
+      end
+    rescue Test::Unit::AssertionFailedError => e
+      failed_assertion = true
+    end
+
+    flunk("assert_fail incorrectly passed") unless failed_assertion
+  end
+
+  def test_assert_fail_succeeds_when_the_block_fails_an_assertion
+    assert_fail do
+      assert_equal 4, 5
+    end
+  end
+end

data/test/assert_greater_than_or_equal_to_test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertGreaterThanOrEqualToTest < Test::Unit::TestCase
+  def test_assert_greater_than_or_equal_to_5_4_succeeds
+    assert_greater_than_or_equal_to(5, 4)
+  end
+
+  def test_assert_greater_than_or_equal_to_4_4_succeeds
+    assert_greater_than_or_equal_to(4, 4)
+  end
+
+  def test_assert_greater_than_or_equal_to_4_5_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_greater_than_or_equal_to(4, 5) }
+  end
+end

data/test/assert_greater_than_test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertGreaterThanTest < Test::Unit::TestCase
+  def test_assert_greater_than_5_4_succeeds
+    assert_greater_than(5, 4)
+  end
+
+  def test_assert_greater_than_4_4_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_greater_than(4, 4) }
+  end
+
+  def test_assert_greater_than_4_5_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_greater_than(4, 5) }
+  end
+end

data/test/assert_less_than_test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertLessThanTest < Test::Unit::TestCase
+  def test_assert_less_than_4_5_succeeds
+    assert_less_than(4, 5)
+  end
+
+  def test_assert_less_than_4_4_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_less_than(4, 4) }
+  end
+
+  def test_assert_less_than_5_4_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_less_than(5, 4) }
+  end
+end

data/test/assert_less_than_test_or_equal_to_test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertLessThanOrEqualToTest < Test::Unit::TestCase
+  def test_assert_less_than_or_equal_to_4_5_succeeds
+    assert_less_than_or_equal_to(4, 5)
+  end
+
+  def test_assert_less_than_or_equal_to_4_4_succeeds
+    assert_less_than_or_equal_to(4, 4)
+  end
+
+  def test_assert_less_than_or_equal_to_5_4_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_less_than_or_equal_to(5, 4) }
+  end
+end

data/test/assert_negative_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertNegativeTest < Test::Unit::TestCase
+  def test_assert_negative_negative_1_succeeds
+    assert_negative(-1)
+  end
+
+  def test_assert_negative_negative_1_point_0_succeeds
+    assert_negative(-1.0)
+  end
+
+  def test_assert_negative_0_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_negative(0) }
+  end
+
+  def test_assert_positive_1_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_negative(1) }
+  end
+
+  def test_assert_positive_1_point_0_succeeds
+    assert_raises(Test::Unit::AssertionFailedError) { assert_negative(1.0) }
+  end
+end

data/test/assert_not_test.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertNotTest < Test::Unit::TestCase
+  def assert_not_false_succeeds
+    assert_not false
+  end
+
+  def test_assert_not_nil_succeeds
+    assert_not nil
+  end
+
+  def test_assert_not_true_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_not true }
+  end
+
+  def test_assert_not_5_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_not 5 }
+  end
+end

data/test/assert_positive_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require (File.expand_path "../test_helper", __FILE__)
+
+class AssertPositiveTest < Test::Unit::TestCase
+  def test_assert_positive_1_succeeds
+    assert_positive(1)
+  end
+
+  def test_assert_positive_1_point_0_succeeds
+    assert_positive(1.0)
+  end
+
+  def test_assert_positive_0_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_positive(0) }
+  end
+
+  def test_assert_positive_negative_1_fails
+    assert_raises(Test::Unit::AssertionFailedError) { assert_positive(-1) }
+  end
+
+  def test_assert_positive_negative_1_point_0_succeeds
+    assert_raises(Test::Unit::AssertionFailedError) { assert_positive(-1.0) }
+  end
+end

data/test/assert_raise_message_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require File.expand_path("../test_helper", __FILE__)
+
+class AssertRaiseMessageTest < Test::Unit::TestCase
+  def test_assert_raise_message_on_expected_error_succeeds
+    assert_raise_message("hello, error!", RuntimeError) do
+      raise RuntimeError, "hello, error!"
+    end
+  end
+
+  def test_assert_raise_message_with_no_exception_fails
+    assert_raises(Test::Unit::AssertionFailedError) do
+      assert_raise_message("hello, error!", RuntimeError) { }
+    end
+  end
+
+  def test_assert_raise_message_with_wrong_exception_fails
+    assert_raises(Test::Unit::AssertionFailedError) do
+      assert_raise_message("hello, error!", ArgumentError) do
+        raise RuntimeError, "hello, error!"
+      end
+    end
+  end
+
+  def test_assert_raise_message_with_wrong_error_message_fails
+    assert_raises(Test::Unit::AssertionFailedError) do
+      assert_raise_message("hello, error!", RuntimeError, "test message comparison") do
+        raise RuntimeError, "hello, errrr!"
+      end
+    end
+  end
+end

data/test/assert_sorted_by_desc_test.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+require File.expand_path("../test_helper", __FILE__)
+
+require "foo"
+require "seahawk"
+
+class AssertSortedByDescTest < Test::Unit::TestCase
+  def test_assert_sorted_by_desc_number_fails
+    assert_raise_message("key must be symbol or string", ArgumentError) do
+      assert_sorted_by_desc 12, []
+    end
+  end
+
+  def test_assert_sorted_by_desc_on_number_fails
+    assert_raise_message("enum must be enumerable", ArgumentError) do
+      assert_sorted_by_desc :foo, 1
+    end
+  end
+
+  def test_assert_sorted_by_desc_on_hash_that_doesnt_respond_to_sort_key_fails
+    assert_raise_message("enum's elements don't respond to the key", ArgumentError) do
+      assert_sorted_by_desc :bar, [{:bar => 2}, {:cow => 1}]
+    end
+  end
+
+  def test_assert_sorted_by_desc_on_array_of_objects_that_dont_respond_to_sort_key_fails
+    assert_raise_message("enum's elements don't respond to the key", ArgumentError) do
+      assert_sorted_by_desc :bar, [Foo.new(3), Seahawk.new(2)]
+    end
+  end
+
+  def test_assert_sorted_by_desc_on_array_of_objects_and_hash_that_dont_respond_to_sort_key_fails
+    assert_raise_message("enum's elements don't respond to the key", ArgumentError) do
+      assert_sorted_by_desc :bar, [Foo.new(2), {:moo => 1}]
+    end
+  end
+
+  def test_assert_sorted_by_desc_on_sorted_array_with_symbol_keys_succeeds
+    assert_sorted_by_desc :bar,  [{:bar => 3},  {:bar => 2},  {:bar => 1}]
+  end
+
+  def test_assert_sorted_by_desc_on_sorted_array_with_string_keys_succeeds
+    assert_sorted_by_desc "bar", [{"bar" => 3}, {"bar" => 2}, {"bar" => 1}]
+  end
+
+  def test_assert_sorted_by_desc_on_unsorted_array_fails
+    assert_raises(Test::Unit::AssertionFailedError) do
+      assert_sorted_by_desc :bar, [{:bar => 2}, {:bar => 1}, {:bar => 3}]
+    end
+  end
+
+  def test_assert_sorted_by_desc_on_sorted_array_of_objects_succeeds
+    foos = [Foo.new(3), Foo.new(2), Foo.new(1)]
+    assert_sorted_by_desc :bar, foos
+  end
+
+  def test_assert_sorted_by_desc_on_unsorted_array_of_objects_fails
+    foos = [Foo.new(3), Foo.new(1), Foo.new(2)]
+    assert_raises(Test::Unit::AssertionFailedError) { assert_sorted_by_desc :bar, foos }
+  end
+
+  def test_assert_sorted_by_desc_on_sorted_object_mash_succeeds
+    assert_sorted_by_desc :bar, [{:bar => 2}, Foo.new(1)]
+  end
+
+  def test_assert_sorted_by_desc_on_unsorted_object_mash_fails
+    assert_raises(Test::Unit::AssertionFailedError) do
+      assert_sorted_by_desc :bar, [Foo.new(1), {:bar => 2}]
+    end
+  end
+end