assay 0.2.0

data/lib/assay/assertions/nil_failure.rb

@@ -0,0 +1,75 @@
+require 'assay/assertions/compare_failure'
+
+module Assay
+
+  class NilFailure < CompareFailure
+
+    def self.assertion_name
+      :nil
+    end
+
+    def self.assertion_operator
+      :nil?
+    end
+
+    # Check assertion.
+    def self.pass?(exp)
+      exp.nil?
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 1
+
+      exp = @arguments[0].inspect
+
+      if @_negated
+        "Expected #{exp} to NOT be nil"
+      else
+        "Expected #{exp} to be nil"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passed if object is +nil+.
+    #
+    def assert_nil(exp, opts={})
+      opts[:backtrace] ||= caller
+      NilFailure.assert(exp, opts)
+    end
+
+    # Passed if object is not +nil+.
+    #
+    #   assert_not_nil(true)
+    #
+    def assert_not_nil(exp, opts={})
+      opts[:backtrace] ||= caller
+      NilFailure.refute(exp, opts)
+    end
+  end
+
+
+  module Matchers
+
+    #
+    #
+    #   value.assert is_nil
+    #
+    def is_nil
+      NilFailure.to_matcher
+    end
+
+    #
+    #
+    #   value.should be_nil
+    #
+    def be_nil
+      NilFailure.to_matcher
+    end
+
+  end
+
+end

data/lib/assay/assertions/raise_failure.rb

@@ -0,0 +1,133 @@
+require 'assay/assertions/execution_failure'
+
+module Assay
+
+  #
+  class RaiseFailure < ExecutionFailure
+
+    def self.assertion_name
+      :raises
+    end
+
+    def self.assertion_name!
+      :not_raised
+    end
+
+    #
+    def self.assert(exp, msg=nil, call=nil) #:yeild:
+      begin
+        yield
+        #msg = msg || fail_message(exp)
+        test = false
+        args = [exp]
+      rescue Exception => err
+        #msg = msg || fail_message(exp, err)
+        test = (exp === err)
+        args = [exp, err]
+      end
+      if !test
+        err = new(msg, :backtrace=>(call || caller), :arguments=>args)
+        fail err
+      end
+    end
+
+    #
+    def self.assert!(exp, msg=nil, call=nil) #:yield:
+      begin
+        yield
+        test = true
+        args = [exp]
+      rescue Exception => err
+        #msg = msg || fail_message!(exp, err)
+        test = (exp === err)
+        args = [exp, err]
+      end
+      if !test
+        err = new(msg, :backtrace=>(call || caller), :arguments=>args)
+        fail err
+      end
+    end
+
+    # Check assertion.
+    #
+    # Note: This is not used by the #assert method.
+    def self.pass?(*exp)
+      begin
+        yield
+        false
+      rescue Exception => e
+        exp.any?{ |x| x === e }
+      end
+    end
+
+    # Check negated assertion.
+    #
+    # Note: This is not used by the #assert! method.
+    def self.fail?(*exp)
+      begin
+        yield
+        true
+      rescue Exception => e
+        !exp.any?{ |x| x === e }
+      end
+    end
+
+    # TODO: how to add `but got class` instead.
+    def to_s
+      return super unless @arguments.size == 1
+
+      exp = @arguments[0].inspect
+      #err = @_arguments[1].inspect
+
+      if @_negated
+        "Expected #{exp} NOT to be raised"
+      else
+        "Expected #{exp} to be raised" #, but was #{err} instead."
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passes if the block raises a given exceptions.
+    #
+    #   assert_raises RuntimeError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    def assert_raises(exp, msg=nil, call=nil, &blk) #:yeild:
+      RaiseFailure.assert(exp, msg=nil, call=nil, &blk)
+    end
+
+    # Passes if the block *does not* raise a given exceptions.
+    #
+    #   assert_not_raised IOError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    def assert_not_raised(exp, msg=nil, call=nil, &blk) #:yeild:
+      RaiseFailure.refute(exp, msg, call, &blk)
+    end
+  end
+
+
+  module Matchers
+    #
+    #
+    #   Exception.assert is_raised{ ... }
+    #
+    def is_raised(&blk)
+      RaiseFailure.to_matcher(&blk)
+    end
+
+    #
+    #
+    #   Exception.should be_raised{ ... }
+    #
+    def be_raised(&blk)
+      RaiseFailure.to_matcher(&blk)
+    end
+  end
+
+end

data/lib/assay/assertions/response_failure.rb

@@ -0,0 +1,87 @@
+require 'assay/assertion'
+
+module Assay
+
+  # Does an object #respond_to? a method call.
+  class ResponseFailure < Assertion
+
+    def self.assertion_name
+      :respond_to
+    end
+
+    def self.assertion_name!
+      :not_respond_to
+    end
+
+    def self.operator_name
+      :respond_to?
+    end
+
+    # Check assertion.
+    def self.pass?(reciever, method)
+      #flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
+      #obj, meth = meth, obj if flip
+      reciever.respond_to?(method)
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 2
+
+      reciever = @arguments[0].inspect
+      method   = @arguments[1].inspect
+
+      if @_negated
+        "Expected #{reciever} (#{reciever.class}) to NOT respond to ##{method}"
+      else
+        "Expected #{reciever} (#{reciever.class}) to respond to ##{method}"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passes if +object+ respond_to? +methods+.
+    #
+    #   assert_respond_to 'bugbear', :slice
+    #
+    def assert_respond_to(reciever, method, opts={})
+      opts[:backtrace] ||= caller
+      ResponseFailure.assert(reciever, method, opts)
+    end
+    alias_method :assert_responds_to, :assert_respond_to
+
+    # Passes if +object+ does not respond_to? +methods+.
+    #
+    #   assert_not_respond_to 'bugbear', :slice
+    #
+    def assert_not_respond_to(reciever, method, opts={})
+      opts[:backtrace] ||= caller
+      ResponseFailure.refute(reciever, method, opts)
+    end
+
+    alias_method :assert_not_responds_to, :assert_not_respond_to
+  end
+
+
+  module Matchers
+    #
+    #
+    #   object.assert is_responsive_to(:method_symbol)
+    #
+    def is_responsive_to(method)
+      ResponseFailure.to_matcher(method)
+    end
+
+    #
+    #
+    #   object.should be_responsive_to(:method_symbol)
+    #
+    def be_responsive_to(method)
+      ResponseFailure.to_matcher(method)
+    end
+  end
+
+end
+

data/lib/assay/assertions/same_failure.rb

@@ -0,0 +1,83 @@
+require 'assay/assertions/compare_failure'
+
+module Assay
+
+  # Comparison assertion for the #eql? method.
+  class SameFailure < CompareFailure
+
+    def self.assertion_name
+      :same
+    end
+
+    def self.assertion_operator
+      :eql?
+    end
+
+    # Check assertion.
+    def self.pass?(exp, act)
+      exp.eql?(act)
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 2
+
+      exp = @arguments[0].inspect
+      act = @arguments[1].inspect
+
+      if @_negated
+        "Expected #{act} to NOT be the same as #{exp}"
+      else
+        "Expected #{act} to be the same as #{exp}"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passes if +expected+ .eq? +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_same 'MY STRING', 'my string'.upcase
+    #
+    def assert_same(exp, act, opts={})
+      opts[:backtrace] ||= caller
+      SameFailure.assert(exp, act, opts)
+    end
+
+    # Passes if not +expected+ .eq? +actual+.
+    #
+    #  assert_not_the_same 'some string', 5
+    #
+    def refute_same(exp, act, opts={})
+      opts[:backtrace] ||= caller
+      SameFailure.refute(exp, act, opts)
+    end
+
+    alias_method :assert_not_same, :refute_same
+  end
+
+
+  module Matchers
+    #
+    #
+    #   object1.assert is_same_as(object2)
+    #
+    def is_same_as(obj)
+      SameFailure.to_matcher(obj)
+    end
+
+    #
+    #
+    #   object1.should be_same_as(object2)
+    #
+    def be_same_as(obj)
+      SameFailure.to_matcher(obj)
+    end
+  end
+
+end

data/lib/assay/assertions/throw_failure.rb

@@ -0,0 +1,123 @@
+require 'assay/assertions/execution_failure'
+
+module Assay
+
+  #
+  class ThrowFailure < ExecutionFailure
+
+    def self.assertion_name
+      :throws
+    end
+
+    def self.assertion_name!
+      :not_thrown
+    end
+
+    # Passes if the block throws expected_symbol
+    #
+    #   assert_throws :done do
+    #     throw :done
+    #   end
+    #
+    def self.pass?(sym, &block)
+      pass = true
+      catch(sym) do
+        begin
+          block.call
+        rescue ArgumentError => err     # 1.9 exception
+          #msg += ", not #{err.message.split(/ /).last}"
+          pass = false
+        rescue NameError => err         # 1.8 exception
+          #msg += ", not #{err.name.inspect}"
+          pass = false
+        end
+      end
+      pass
+    end
+
+    # Passes if the block throws expected_symbol
+    #
+    #   assert_not_thrown :done do
+    #     throw :chimp
+    #   end
+    #
+    # FIXME: Is this correct?
+    def self.fail?(sym, &block)
+      pass = false
+      catch(sym) do
+        begin
+          block.call
+        rescue ArgumentError => err     # 1.9 exception
+          #msg += ", not #{err.message.split(/ /).last}"
+          pass = true
+        rescue NameError => err         # 1.8 exception
+          #msg += ", not #{err.name.inspect}"
+          pass = true
+        end
+      end
+      pass
+    end
+
+    #
+    def to_s
+      return super unless @arguments.size == 1
+
+      sym = @arguments[0].inspect
+
+      if @_negated
+        "Expected #{sym} to have been thrown"
+      else
+        "Expected #{sym} NOT to have been thrown"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passes if the block throws expected_symbol
+    #
+    #   assert_throws :done do
+    #     throw :done
+    #   end
+    #
+    def assert_throws(sym, opts={}, &blk)
+      opts[:backtrace] ||= caller
+      ThrowFailure.assert(sym, opts, &blk)
+    end
+
+    # Passes if the block throws expected_symbol
+    #
+    #   refute_throws :done do
+    #     throw :chimp
+    #   end
+    #
+    def refute_throws(sym, opts={}, &blk)
+      opts[:backtrace] ||= caller
+      ThrowFailure.refute(sym, opts, &blk)
+    end
+
+    alias_method :assert_not_thrown, :refute_throws
+  end
+
+
+  module Matchers
+    #
+    #
+    #   :symbol.assert is_thrown{ ... }
+    #
+    def is_thrown(&blk)
+      ThrowFailure.to_matcher(&blk)
+    end
+
+    #
+    #
+    #   :symbol.should be_thrown{ ... }
+    #
+    def be_thrown(&blk)
+      ThrowFailure.to_matcher(&blk)
+    end
+  end
+
+end
+