assay 0.2.0

data/lib/assay/adapters/testunit.rb

@@ -0,0 +1,42 @@
+module Test #:nodoc:
+  module Unit #:nodoc:
+    class TestCase #:nodoc:
+      # Runs the individual test method represented by this
+      # instance of the fixture, collecting statistics, failures
+      # and errors in result.
+      def run(result)
+        yield(STARTED, name)
+        @_result = result
+        begin
+          setup
+          __send__(@method_name)
+        rescue AssertionFailedError => e
+          add_failure(e.message, e.backtrace)
+        rescue Exception => e
+          if e.respond_to?(:assertion?) && e.assertion?
+            add_failure(e.message, e.backtrace)
+          else
+            raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
+            add_error($!)
+          end
+        ensure
+          begin
+            teardown
+          rescue AssertionFailedError => e
+            add_failure(e.message, e.backtrace)
+          rescue Exception => e
+            if e.respond_to?(:assertion?) && e.assertion?
+              add_failure(e.message, e.backtrace)
+            else
+              raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
+              add_error($!)
+            end
+          end
+        end
+        result.add_run
+        yield(FINISHED, name)
+      end 
+    end
+  end
+end
+

data/lib/assay/assertion.rb

@@ -0,0 +1,148 @@
+require 'ansi/diff'
+require 'assay/matcher'
+
+module Assay
+
+  #
+  class Assertion < Exception
+
+    # When displaying errors, use this as a rule of thumb
+    # for determining when the inspected object will be too
+    # big for a single line message.
+    SIZE_LIMIT = 13
+
+    # Returns Matcher for the failure class.
+    def self.to_matcher(*args, &blk)
+      Matcher.new(self, *args, &blk)
+    end
+
+    #
+    def self.assertable_method
+      "assert_#{assertion_name}"
+    end
+
+    #
+    def self.assert(*args, &blk)
+      opts = Hash === args.last ? args.pop : {}
+
+      backtrace = opts[:backtrace] || caller
+      message   = opts[:message]
+
+      err = new(message, *args, &blk)
+      err.set_backtrace(backtrace)
+      err.assert
+
+      #chk  = check(*args, &blk)
+      #msg  = fail_message(*args, &blk)
+      #if !chk
+      #  msg = opts[:message]
+      #  btr = opts[:backtrace] || caller
+      #  err = new(msg, *args)
+      #  err.set_backtrace(btr)
+      #  fail err
+      #end
+    end
+
+    #
+    def self.refute(*args, &blk)
+      opts = Hash === args.last ? args.pop : {}
+
+      backtrace = opts[:backtrace] || caller
+      message   = opts[:message]
+
+      err = new(message, *args, &blk)
+      err.set_backtrace(backtrace)
+      err.refute
+
+      #opts = Hash === args.last ? args.pop : {}
+      #chk  = check!(*args, &blk)
+      ##msg  = fail_message!(*args, &blk)
+      #if !chk
+      #  msg = opts[:message]
+      #  btr = opts[:backtrace] || caller
+      #  err = new(msg, :backtrace=>btr, :arguments=>args)
+      #  fail err
+      #end
+    end
+
+    #
+    def self.pass?(*args, &blk)
+      raise NotImplementedError
+    end
+
+    #
+    def self.fail?(*args, &blk)
+      ! pass?(*args, &blk)
+    end
+
+    #
+    def initialize(message=nil, *arguments, &block)
+      message ? super(message % arguments) : super()
+
+      @arguments = arguments
+      @block     = block
+
+      #set_arguments options[:arguments] if options[:arguments]
+      #set_negative  options[:negated]   if options[:negated]
+      #set_backtrace options[:backtrace] if options[:backtrace]
+    end
+
+    # Failure is always a type of assertion.
+    #
+    # This method allows Assay's classes to work in any test framework
+    # that supports this interface.
+    def assertion?
+      true  # @assertion = true if @assertion.nil?
+    end
+
+    #
+    def pass?
+      self.class.pass?(*@arguments, &@block) #^ @negative
+    end
+
+    #
+    def fail?
+      not pass?
+    end
+
+    #
+    def assert
+      #@negative = false
+      raise self unless pass?
+    end
+
+    #
+    def refute
+      #@negative = true
+      raise self unless fail?
+    end
+
+    #
+    def negative?
+      @negative
+    end
+
+    # Set whether this failure was the inverse of it's normal meaning.
+    # For example, `!=` rather than `==`.
+    def set_negative(negative)
+      @negative = !!negative
+    end
+
+    # Set arguments used to make assertion.
+    def set_arguments(arguments)
+      @arguments = arguments
+      #@block    = block
+    end
+
+    #
+    def to_s
+      if @negative
+        "NOT " + super()
+      else
+        super()
+      end
+    end
+
+  end
+
+end

data/lib/assay/assertions/compare_failure.rb

@@ -0,0 +1,60 @@
+require 'assay/assertion'
+
+module Assay
+
+  class CompareFailure < Assertion
+
+    def self.assertion_name
+      :like
+    end
+
+    # Test assertion.
+    def self.pass?(exp, act)
+      exp.equal?(act) ||
+      exp.eq?(act)    ||
+      exp.==(act)     ||
+      exp.===(act)
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 2
+
+      iexp = @arguments[0].inspect
+      iact = @arguments[1].inspect
+
+      if @_negated
+        "Expected #{iact} to NOT be like #{iexp}"
+      else
+        "Expected #{iact} to be like #{iexp}"
+      end
+    end
+
+  end
+
+
+  module Assertives
+
+  end
+
+
+  module Matchers
+    #
+    #
+    #   object1.should be_like(object2)
+    #
+    def be_like(act)
+      CompareFailure.to_matcher(act)
+    end
+
+    #
+    #
+    #   object1.should be_like(object2)
+    #
+    def is_like(act)
+      CompareFailure.to_matcher(act)
+    end
+  end
+
+end
+

data/lib/assay/assertions/delta_failure.rb

@@ -0,0 +1,80 @@
+require 'assay/assertions/compare_failure'
+
+module Assay
+
+  # TODO: Support Range
+  class DeltaFailure < CompareFailure
+
+    #
+    def self.assertion_name
+      :in_delta
+    end
+
+    # Check assertion.
+    def self.pass?(exp, act, delta)
+      case delta
+      when Numeric
+        (exp.to_f - act.to_f).abs <= delta.to_f
+      else
+        exp - act <= delta
+      end
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 3
+
+      exp   = @arguments[0].inspect
+      act   = @arguments[1].inspect
+      delta = @arguments[2].inspect
+
+      if @_negated
+        "Expected #{exp} to NOT be within #{delta} of #{act}"
+      else
+        "Expected #{exp} to be within #{delta} of #{act}"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passes if expected and actual are equal within delta tolerance.
+    #
+    #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
+    #
+    def assert_in_delta(exp, act, delta, opts={})
+      opts[:backtrace] ||= caller
+      DeltaFailure.assert(exp, act, delta, opts)
+    end
+
+    # Passes if expected and actual are equal not within delta tolerance.
+    #
+    #   assert_not_in_delta 0.05, (50000.0 / 10**6), 0.00001
+    #
+    def self.not_in_delta(exp, act, delta, opts)
+      opts[:backtrace] ||= caller
+      DeltaFailure.refute(exp, act, delta, opts)
+    end
+  end
+
+
+  module Matchers
+    #
+    #
+    #   value1.should be_within(delta, value2)
+    #
+    def is_within(delta, act)
+      DeltaFailure.to_matcher(act, delta)
+    end
+
+    #
+    #
+    #   value1.assert is_within(delta, value2)
+    #
+    def be_within(delta, act)
+      DeltaFailure.to_matcher(act, delta)
+    end
+  end
+
+end

data/lib/assay/assertions/empty_failure.rb

@@ -0,0 +1,76 @@
+require 'assay/assertion'
+
+module Assay
+
+  class EmptyFailure < Assertion
+
+    def self.assertion_name
+      :empty
+    end
+
+    def self.assertion_operator
+      :empty?
+    end
+
+    # Check assertion.
+    def self.pass?(exp)
+      exp.empty?
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 1
+
+      exp = @arguments.first.inspect
+
+      if @_negated
+        "Expected #{exp} to NOT be empty"  
+      else
+        "Expected #{exp} to be empty"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passed if object is +true+.
+    #
+    def assert_empty(exp, opts={})
+      opts[:backtrace] ||= caller
+      EmptyFailure.assert(exp, opts)
+    end
+
+    # Passed if object is not +true+.
+    #
+    #   assert_not_true(false)
+    #
+    def refute_empty(exp, opts={})
+      opts[:backtrace] ||= caller
+      EmptyFailure.refute(exp, opts)
+    end
+
+    alias_method :assert_not_empty, :refute_empty
+  end
+
+
+  module Matchers
+    # Empty?
+    #
+    #   object.assert is_true
+    #
+    def is_empty
+      EmptyFailure.to_matcher
+    end
+
+    # Empty?
+    #
+    #   object.should be_empty
+    #
+    def be_empty
+      EmptyFailure.to_matcher
+    end
+  end
+
+end
+

data/lib/assay/assertions/equality_failure.rb

@@ -0,0 +1,105 @@
+require 'assay/assertions/compare_failure'
+
+module Assay
+
+  #
+  class EqualityFailure < CompareFailure
+
+    #
+    def self.assertion_name
+      :equal
+    end
+
+    #
+    def self.assertion_operator
+      :==
+    end
+
+    # Check assertion.
+    def self.pass?(exp, act)
+      exp == act
+    end
+
+    # Check negated assertion.
+    def self.fail?(exp, act)
+      exp != act
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 2
+
+      oper = @_negated ? "!=" : "=="
+      iexp = @arguments[0].inspect
+      iact = @arguments[1].inspect
+
+      if iexp.size > SIZE_LIMIT or iact.size > SIZE_LIMIT
+        diff = ANSI::Diff.new(iact, iexp)
+        "a #{oper} b\na) #{diff.diff1}\nb) #{diff.diff2}"
+      else
+        "#{iact} #{oper} #{iexp}"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passes if expected == +actual.
+    #
+    # Note that the ordering of arguments is important,
+    # since a helpful error message is generated when this
+    # one fails that tells you the values of expected and actual.
+    #
+    #   assert_equal 'MY STRING', 'my string'.upcase
+    #
+    def assert_equal(exp, act, opts={})
+      opts[:backtrace] ||= caller
+      #message   = opts[:message]
+      EqualityFailure.assert(exp, act, opts)
+      #err = EqualityFailure.new(message, exp, act)
+      #err.set_backtrace(backtrace)
+      #err.assert(opts)
+    end
+
+    # Passes if expected != actual
+    #
+    #  assert_not_equal 'some string', 5
+    #
+    def assert_not_equal(exp, act, opts)
+       opts[:backtrace] ||= caller
+       EqualityFailure.refute(exp, act, opts)
+    end
+  end
+
+
+  module Matchers
+    # Passes if +expected+ == +actual+.
+    #
+    #   'MY STRING'.assert is_equal_to('my string'.upcase)
+    #   'MY STRING'.refute is_equal_to('another string')
+    #
+    def is_equal_to(exp, opts={})
+      EqualityFailure.to_matcher(exp)
+    end
+
+    # Passes if +expected+ == +actual+.
+    #
+    #   'MY STRING'.should be_equal_to('my string'.upcase)
+    #   'MY STRING'.should_not be_equal_to('another string')
+    #
+    def be_equal_to(exp)
+      EqualityFailure.to_matcher(exp)
+    end
+
+    ## # Passes if expected != actual
+    ## #
+    ## #  'some string'.should not_be_equal_to('foo')
+    ## #
+    ## def not_be_equal_to(exp, act, opts)
+    ##   opts[:backtrace] ||= caller
+    ##   EqualityFailure.to_matcher!(exp, opts)
+    ## end
+  end
+
+end