rubyunit 0.3.16 → 0.3.17

data/lib/RubyUnit/Assertions/Comparisons.rb

@@ -0,0 +1,205 @@
+require_relative 'Root'
+
+module RubyUnit
+  module Assertions
+    module Comparisons
+      include RubyUnit::AssertionMessage
+      include Assertions::Root
+
+      #
+      # Assert that two values are equal.
+      # * raises RubyUnit::AssertionFailure unless _expected_ equals _actual_
+      #
+      # expected::
+      #   The value that is forbidden by the assertion
+      #
+      # actual::
+      #   The value that is being checked by the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertEqual 42, 24, "This will fail"  # => fail
+      #
+      def assertEqual expected, actual, message = nil
+        __assert (expected == actual), ASSERT_EQUAL_ERROR, message, {:expected=>expected, :actual=>actual}
+      end
+
+      #
+      # Assert that two values are NOT equal.
+      # * raises RubyUnit::AssertionFailure if _illegal_ equals _actual_
+      #
+      # illegal::
+      #   The value that is not allowed by the assertion
+      #
+      # actual::
+      #   The value that is being checked by the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertNotEqual 3.14, 3.14, "This will fail"  # => fail
+      #
+      def assertNotEqual illegal, actual, message = nil
+        __reject (illegal == actual), ASSERT_NOT_EQUAL_ERROR, message, {:illegal=>illegal, :actual=>actual} 
+      end
+
+      #
+      # Assert that one value is greater than another.
+      # * raises RubyUnit::AssertionFailure unless _greater_ is greater than _value_
+      #
+      # greater::
+      #   The value that should be greater
+      #
+      # value::
+      #   The value that is being checked by the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertGreaterThan 24, 42, "This will fail"  # => fail
+      #
+      def assertGreaterThan greater, value, message = nil
+        __assert (greater > value), ASSERT_GREATERTHAN_ERROR, message, {:greater=>greater, :value=>value}
+      end
+
+      #
+      # Assert that one value is greater than another.
+      # * raises RubyUnit::AssertionFailure unless _greater_ is greater than or equal to _value_
+      #
+      # greater::
+      #   The value that should be greater than or equal
+      #
+      # value::
+      #   The value that is being checked by the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertGreaterThanOrEqual 24, 42, "This will fail"  # => fail
+      #
+      def assertGreaterThanOrEqual greater, value, message = nil
+        __assert (greater >= value), ASSERT_GREATERTHANOREQUAL_ERROR, message, {:greater=>greater, :value=>value}
+      end
+
+      #
+      # Assert that one value is less than another.
+      # * raises RubyUnit::AssertionFailure unless _less_ is less than _value_
+      #
+      # less::
+      #   The value that should be less
+      #
+      # value::
+      #   The value that is being checked by the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertLessThan 42, 24, "This will fail"  # => fail
+      #
+      def assertLessThan less, value, message = nil
+        __assert (less < value), ASSERT_LESSTHAN_ERROR, message, {:less=>less, :value=>value}
+      end
+
+      #
+      # Assert that one value is less than another.
+      # * raises RubyUnit::AssertionFailure unless _less_ is less than or equal to _value_
+      #
+      # less::
+      #   The value that should be less than or equal
+      #
+      # value::
+      #   The value that is being checked by the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertLessThanOrEqual 42, 24, "This will fail"  # => fail
+      #
+      def assertLessThanOrEqual less, value, message = nil
+        __assert (less <= value), ASSERT_LESSTHANOREQUAL_ERROR, message, {:less=>less, :value=>value}
+      end
+
+      #
+      # Assert that a value matches a Regexp pattern.
+      # * raises RubyUnit::AssertionFailure unless _value_ matches _pattern_
+      #
+      # pattern::
+      #   A Regexp pattern expected by the assertion
+      #
+      # value::
+      #   The value that is being checked for the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertMatch /^Hello/, 'Goodbye!', "This will fail"  # => fail
+      #
+      def assertMatch pattern, value, message = nil
+        pattern = [pattern] unless pattern.is_a? Array
+        pattern.each do |regex|
+          __assert (value =~ regex), ASSERT_MATCH_ERROR, message, {:pattern=>pattern, :value=>value}
+        end
+      end
+
+      #
+      # Assert that a value does not match a Regexp pattern.
+      # * raises RubyUnit::AssertionFailure if _value_ matches _pattern_
+      #
+      # pattern::
+      #   A Regexp pattern excluded by the assertion
+      #
+      # value::
+      #   The value that is being checked for the assertion
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertMatch /^Good/, 'Goodbye!', "This will fail"  # => fail
+      #
+      def assertNotMatch exclusion, value, message = nil
+        __reject (value =~ exclusion), ASSERT_NO_MATCH_ERROR, message, {:exclusion=>exclusion, :value=>value}
+      end
+
+      #
+      # Assert that two objects are the same object
+      # * raises RubyUnit::AssertionFailure unless _expected_ and _actual_ are
+      #   the same object.
+      #
+      # expected::
+      #   The expected object
+      #
+      # actual::
+      #   The object that is being checked against _expected_
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertSame '42', 42, 'Not even close.'  # => fail
+      #
+      def assertSame expected, actual, message = nil
+        __assert (expected.equal? actual), ASSERT_SAME_ERROR, message, {:expected=>expected, :actual=>actual}
+      end
+
+      #
+      # Assert that two objects are not the same object
+      # * raises RubyUnit::AssertionFailure if _illegal_ and _actual_ are the
+      #   same object.
+      #
+      # illegal::
+      #   The expected that it shouldn't be
+      #
+      # actual::
+      #   The object that is being checked against _illegal_
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertNotSame value, value, 'Imagine that!'  # => fail
+      #
+      def assertNotSame illegal, actual, message = nil
+        __reject (illegal.equal? actual), ASSERT_NOT_SAME_ERROR, message, {:illegal=>illegal, :actual=>actual}
+      end
+    end
+  end
+end

data/lib/RubyUnit/Assertions/Exceptions.rb

@@ -0,0 +1,122 @@
+require_relative 'Root'
+
+module RubyUnit
+  module Assertions
+    module Exceptions
+      include RubyUnit::AssertionMessage
+      include Root
+    
+      ##
+      # Assert that no exception is raised.
+      # * raises RubyUnit::AssertionFailure if any exception is raised
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      # &block::
+      #   The code block that is executed
+      #
+      #  assertNothingRaised 'Not expecting an exception!' do
+      #    # do something
+      #  end
+      #
+      def assertNothingRaised message = nil, &block
+        __assert_block do
+          begin
+            yield
+            true # just in case the block yields 'false' or 'nil'
+          rescue Exception => e
+            __fail ASSERT_NOTHING_RAISED_ERROR, message, {:exception=>e.message}
+          end
+        end
+      end
+
+      ##
+      # Assert that a specified exception message is raised.
+      # * raises RubyUnit::AssertionFailure unless the correct Exception message is raised
+      #
+      # pattern::
+      #   The String or Regexp that will be used to validate the Exception message
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      # &block::
+      #   The code block that is expected to throw the Exception
+      #
+      #  assertRaiseMessage /^Invalid/, 'Expecting an exception!' do
+      #    # do something
+      #  end
+      #
+      def assertRaiseMessage pattern, message = nil, &block
+        assertRaiseExpected Exception, pattern, message, &block
+      end
+
+      ##
+      # Assert that a specified exception type is raised.
+      # * raises RubyUnit::AssertionFailure unless the correct Exception type is raised
+      #
+      # e::
+      #   The Exception class that is expected.
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      # &block::
+      #   The code block that is expected to throw the Exception
+      #
+      #  assertRaiseKindOf StandardError, 'Expecting an exception!' do # => fail
+      #    # do something
+      #  end
+      #
+      def assertRaiseKindOf e, message = nil, &block
+        assertRaiseExpected e, '', message, &block
+      end
+
+      ##
+      # Assert that a specified exception is raised.
+      # * raises RubyUnit::AssertionFailure unless the correct Exception is raised
+      #
+      # exception::
+      #   The Exception class that is expected.
+      #
+      # pattern::
+      #   The String or Regexp that will be used to validate the Exception message
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      # &block::
+      #   The code block that is expected to throw the Exception
+      #
+      #  assertRaiseExpected StandardError, /^Invalid/, 'Expecting an exception!' do
+      #    raise StandardError, 'Invalid Retroincabulator'
+      #  end
+      #
+      def assertRaiseExpected exception, pattern, message = nil &block
+        __assert_exception pattern, exception
+        __assert_block ASSERT_RAISE_EXPECTED_ERROR, message, {:exception=>exception, :pattern=>pattern} do
+          e = false
+          begin
+            yield
+          rescue exception => e
+            assertEqual pattern, e.message if pattern.is_a? String and pattern.length > 0
+            assertMatch pattern, e.message if pattern.is_a? Regexp
+          end
+          e
+        end
+      end
+
+      private
+      ##
+      # Validate the parameters for exception assertions
+      # * raises ArgumentError if _pattern_ is not a String or Regexp
+      # * raises ArgumentError unless _e_ is a descendent of the Exception class
+      #
+      def __assert_exception pattern, e = Exception # :nodoc:
+        raise ArgumentError, "Message patter must be a Regexp or String, got #{pattern.class}" unless pattern.is_a? Regexp or pattern.is_a? String
+        raise ArgumentError, "Expected subclass of Exception, got #{e.class}" unless e < Exception
+      end
+    end
+  end
+end

data/lib/RubyUnit/Assertions/Methods.rb

@@ -0,0 +1,162 @@
+require_relative 'Root'
+
+module RubyUnit
+  module Assertions
+    module Methods
+      include RubyUnit::AssertionMessage
+      include Root
+
+      #
+      # Assert that an object responds to particular method
+      # * raises RubyUnit::AssertionFailure unless _object_ responds to _method_
+      #
+      # object::
+      #   The object to check
+      #
+      # method::
+      #   The method to assert on the object
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertRespondTo /^Regexp/, :length, 'It does not, so... no'  # => fail
+      #
+      def assertRespondTo object, method, message = nil
+        __assert (object.respond_to? method), ASSERT_RESPOND_TO_ERROR, message, {:object=>object, :method=>method}
+      end
+
+      #
+      # Assert that an object does not respond to a particular method
+      # * raises RubyUnit::AssertionFailure if _object_ responds to _method_
+      #
+      # object::
+      #   The object to check
+      #
+      # method::
+      #   The method to assert on the object
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertNotRespondTo 25, :integer?, 'It does, so close'  # => fail
+      #
+      def assertNotRespondTo object, method, message = nil
+        __assert (object.respond_to? method), ASSERT_NOT_RESPOND_TO_ERROR, message, {:object=>object, :method=>method}
+      end
+
+      #
+      # Assert that an object has defined the specified method.
+      # * raises RubyUnit::AssertionFailure unless _klass_ has defined _method_
+      #
+      # klass::
+      #   The object to check for _method_
+      #
+      # method::
+      #   The method to check
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertMethod String, :integer?, 'Nope' # => fail
+      #
+      def assertMethod klass, method, message = nil
+        assertInclude klass.methods, method, message
+      end
+
+      #
+      # Assert that an object has not defined the specified method.
+      # * raises RubyUnit::AssertionFailure if _klass_ has defined _method_
+      #
+      # klass::
+      #   The object to check for _method_
+      #
+      # method::
+      #   The method to check
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertNotMethod Integer, :integer?, 'Nope' # => fail
+      #
+      def assertNotMethod klass, not_method, message = nil
+        assertNotInclude klass.methods, not_method, message
+      end
+
+      #
+      # Assert that an object has defined the specified instance method.
+      # * raises RubyUnit::AssertionFailure unless _klass_ has defined _instance_method_
+      #
+      # klass::
+      #   The object to check for _instance_method_
+      #
+      # method::
+      #   The method to check
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertInstanceMethod String, :integer?, 'Nope' # => fail
+      #
+      def assertInstanceMethod klass, instance_method, message = nil
+        assertInclude klass.instance_methods, instance_method, message
+      end
+
+      #
+      # Assert that an object has not defined the specified instance method.
+      # * raises RubyUnit::AssertionFailure unless _klass_ has defined _not_instance_method_
+      #
+      # klass::
+      #   The object to check for _not_instance_method_
+      #
+      # method::
+      #   The method to check
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertNotInstanceMethod Integer, :integer?, 'Nope' # => fail
+      #
+      def assertNotInstanceMethod klass, not_instance_method, message = nil
+        assertNotInclude klass.instance_methods, not_instance_method, message
+      end
+
+      #
+      # Assert that an Class has defined the specified class method.
+      # * raises RubyUnit::AssertionFailure unless _klass_ has defined _class_method_
+      #
+      # klass::
+      #   The object to check for _class_method_
+      #
+      # method::
+      #   The method to check
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertClassMethod String, :integer?, 'Nope' # => fail
+      #
+      def assertClassMethod klass, class_method, message = nil
+        assertInclude klass.singleton_methods, class_method, message
+      end
+
+      #
+      # Assert that an Class has not defined the specified class method.
+      # * raises RubyUnit::AssertionFailure unless _klass_ has defined _not_class_method_
+      #
+      # klass::
+      #   The object to check for _not_class_method_
+      #
+      # method::
+      #   The method to check
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      #  assertNotClassMethod String, :new, 'Nope' # => fail
+      #
+      def assertNotClassMethod klass, not_class_method, message = nil
+        assertNotInclude klass.singleton_methods, not_class_method, message
+      end
+    end
+  end
+end

data/lib/RubyUnit/Assertions/Root.rb

@@ -0,0 +1,93 @@
+module RubyUnit
+  module Assertions
+    module Root
+      private
+      ##
+      # Builds the message that will be used with the assertion
+      # * raises RubyUnit::AssertionFailure
+      # * raises ArgumentError unless error is a String
+      # * raises ArgumentError unless message is nil or a String
+      # * raises ArgumentError unless data is a Hash
+      #
+      # error::
+      #   The assertion description
+      #
+      # message::
+      #   The message provided by the test for the assertion
+      #
+      # data::
+      #   The data associated with assertion failure
+      #
+      #  __fail 'Failing Test', message, {'expected' => expected, 'actual' => actual }
+      #
+      def __fail error, message, data = {} # :nodoc:
+        raise ArgumentError, 'Error description must be a String' unless error.is_a? String
+        raise ArgumentError, 'Failure message must be String' unless message.nil? or message.is_a? String
+        raise ArgumentError, 'Failure data must be a Hash' unless data.is_a? Hash
+        raise AssertionFailure.new({'Assertion Failure'=>message}.merge data), error
+      end
+
+      ##
+      # The assertion wrapper is responsible for doing everything that must be done
+      # on each assertion.
+      # * keep track of the total number of assertions
+      #
+      # &block::
+      #   The assertion which is being wrapped
+      #
+      def __assert_block error = '', message = nil, data = {} # :nodoc:
+        Assertions.add_assertion
+        result = block_given? ? yield : false
+        __fail error, message, data unless result
+        result
+      end
+
+      ##
+      # This is now a wrapper for __assert_block so it can be called 'nicely' in one line
+      # * raises RubyUnit::AssertionFailure unless _value_ is true 
+      #
+      # value::
+      #   The value to be asserted
+      #
+      # error::
+      #   The error associated with the assertion being checked
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      # data::
+      #   The data associated with assertion
+      #
+      #  __assert value, 'Failed to assert value is true', message, {:value=>value}
+      #
+      def __assert value, error, message, data # :nodoc:
+        __assert_block error, message, data do
+          # this will result in returning true if an Exception is not raised
+          value
+        end
+      end
+
+      ##
+      # Internally validate that an assertion is false or nil
+      # * raises RubyUnit::AssertionFailure unless _value_ is false or nil 
+      #
+      # value::
+      #   The value to be asserted
+      #
+      # error::
+      #   The error associated with the assertion being checked
+      #
+      # message::
+      #   The message provided to be reported for a failure
+      #
+      # data::
+      #   The data associated with assertion
+      #
+      #  __reject value, 'Failed to assert value is not true', message, {:value=>value}
+      #
+      def __reject value, error, message, data # :nodoc:
+        __assert !value, error, message, data
+      end
+    end
+  end
+end