assay 0.3.0 → 0.4.0

data/lib/assay/assertions/identity_failure.rb

@@ -1,85 +0,0 @@
-require 'assay/assertions/compare_failure'
-
-module Assay
-
-  class IdentityFailure < CompareFailure
-
-    def self.assertion_name
-      :identical
-    end
-
-    def self.assertion_operator
-      :equal?
-    end
-
-    #def self.fail_message(exp, act)
-    #  "Expected #{act.inspect} to be identical to #{exp.inspect}"
-    #end
-
-    #def self.fail_message!(exp, act)
-    #  "Expected #{act.inspect} not to be identical to #{exp.inspect}"
-    #end
-
-    # Check assertion.
-    def self.pass?(exp, act)
-      exp.object_id == act.object_id
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 2
-
-      iexp = @arguments[0].inspect
-      iact = @arguments[1].inspect
-
-      if @_negated
-        "Expected #{iact} not to be identical to #{iexp}"
-      else
-        "Expected #{iact} to be identical to #{iexp}"
-      end
-    end
-
-  end
-
-
-  module Assertives
-    # Passes if +actual+ .equal? +expected+ (i.e. they are the same instance).
-    #
-    #   o = Object.new
-    #   assert_identical(o, o)
-    #
-    def assert_identical(exp, act, msg=nil)
-      IdentityFailure.assert(exp, act, :message=>msg, :backtrace=>caller)
-    end
-
-    # Passes if ! actual .equal? expected
-    #
-    #   assert_not_identical(Object.new, Object.new)
-    #
-    def assert_not_identical(exp, act, msg=nil)
-      IdentityFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
-    end
-  end
-
-
-  module Matchers
-    #
-    #
-    #   object1.assert is_identical_to(object2)
-    #
-    def is_identical_to(obj)
-      IdentityFailure.to_matcher(obj)
-    end
-
-    #
-    #
-    #   object1.should be_identical_to(object2)
-    #
-    def be_identical_to(obj)
-      IdentityFailure.to_matcher(obj)
-    end
-
-  end
-
-end

data/lib/assay/assertions/instance_failure.rb

@@ -1,76 +0,0 @@
-require 'assay/assertions/compare_failure'
-
-module Assay
-
-  class InstanceFailure < CompareFailure
-
-    def self.assertion_name
-      :instance
-    end
-
-    def self.assertion_operator
-      :instance_of?
-    end
-
-    # Check assertion.
-    def self.pass?(exp, act)
-      exp.instance_of?(act)
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 2
-
-      exp = @arguments[0].inspect
-      act = @arguments[1].inspect
-
-      if @_negated
-        "Expected #{act} to NOT be an instance of #{exp}"  
-        else
-        "Expected #{act} to be an instance of #{exp}"
-      end
-    end
-  end
-
-
-  module Assertives
-    # Passes if object .instance_of? klass
-    #
-    #   assert_instance_of(String, 'foo')
-    #
-    def assert_instance_of(cls, obj, msg=nil)
-      InstanceFailure.assert(cls, obj, :message=>msg, :backtrace=>caller)
-    end
-
-    # Passes if object .instance_of? klass
-    #
-    #   assert_instance_of(String, 'foo')
-    #
-    def refute_instance_of(cls, obj, msg=nil)
-      InstanceFailure.refute(cls, obj, :message=>msg, :backtrace=>caller)
-    end
-
-    alias_method :assert_not_instance_of, :refute_instance_of
-  end
-
-
-  module Matchers
-    #
-    #
-    #   object.assert is_instance_of(class)
-    #
-    def is_instance_of(cls)
-      InstanceFailure.to_matcher(cls)
-    end
-
-    #
-    #
-    #   object.should be_instance_of(class)
-    #
-    def be_instance_of(cls)
-      InstanceFailure.to_matcher(cls)
-    end
-  end
-
-end

data/lib/assay/assertions/kind_failure.rb

@@ -1,80 +0,0 @@
-require 'assay/assertions/compare_failure'
-
-module Assay
-
-  # Comparison assertion for #kind_of?
-  #
-  #   KindFailure.pass?(1, Integer)  #=> true
-  #   KindFailure.fail?(1, String)   #=> true
-  #
-  class KindFailure < CompareFailure
-
-    def self.assertion_name
-      :kind_of
-    end
-
-    def self.assertion_operator
-      :kind_of?
-    end
-
-    # Check assertion.
-    def self.pass?(exp, act)
-      exp.kind_of? act
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 2
-
-      exp = @arguments[0].inspect
-      act = @arguments[1].inspect
-
-      if @_negated
-        "Expected #{act} to be kind of #{exp}"
-      else
-        "Expected #{act} to be kind of #{exp}"
-      end
-    end
-  end
-
-
-  module Assertives
-    # Passes if object .kind_of? klass
-    #
-    #   assert_kind_of(Object, 'foo')
-    #
-    def assert_kind_of(cls, obj, msg=nil)
-      KindFailure.assert(cls, obj, :message=>msg, :backtrace=>caller)
-    end
-
-    # Passes if object .kind_of? klass
-    #
-    #   assert_not_kind_of(Object, 'foo')
-    #
-    def refute_kind_of(cls, obj, msg=nil)
-      KindFailure.refute(cls, obj, :message=>msg, :backtrace=>caller)
-    end
-    alias_method :assert_not_kind_of, :refute_kind_of
-  end
-
-
-  module Matchers
-    #
-    #
-    #   object.assert is_a_kind_of(class)
-    #
-    def is_kind_of(cls)
-      KindFailure.to_matcher(cls) 
-    end
-
-    #
-    #
-    #   object.should be_a_kind_of(class)
-    #
-    def be_kind_of(cls)
-      KindFailure.to_matcher(cls)
-    end
-  end
-
-end

data/lib/assay/assertions/match_failure.rb

@@ -1,85 +0,0 @@
-require 'assay/assertions/compare_failure'
-
-module Assay
-
-  class MatchFailure < CompareFailure
-
-    def self.assertion_name
-      :match
-    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 self.assertable_method
-      :assert_match
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 2
-
-      exp = @arguments[0].inspect
-      act = @arguments[1].inspect
-
-      if @_negated
-        "Expected #{act} !~ #{exp}"
-      else
-        "Expected #{act} =~ #{exp}"
-      end
-    end
-
-  end
-
-
-  module Assertives
-    # Passes if string =~ pattern.
-    #
-    #   assert_match(/\d+/, 'five, 6, seven')
-    #
-    def assert_match(exp, act, msg=nil)
-      MatchFailure.assert(exp, act, :message=>msg, :backtrace=>caller)
-    end
-
-    # Passes if regexp !~ string
-    #
-    #   refute_match(/two/, 'one 2 three')
-    #
-    def refute_match(exp, act, msg=nil)
-      MatchFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
-    end
-  end
-
-
-  module Matchers
-    #
-    #
-    #   object.assert is_a_match_for(regexp)
-    #
-    def is_match_for(regexp)
-      MatchFailure.to_matcher(regexp)
-    end
-
-    #
-    #
-    #   object.should be_a_match_for(regexp)
-    #
-    def be_match_for(regexp)
-      MatchFailure.to_matcher(regexp)
-    end
-  end
-
-end

data/lib/assay/assertions/nil_failure.rb

@@ -1,75 +0,0 @@
-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 @mesg if @mesg
-      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, msg=nil)
-      NilFailure.assert(exp, :message=>msg, :backtrace=>caller)
-    end
-
-    # Passed if object is not +nil+.
-    #
-    #   assert_not_nil(true)
-    #
-    def assert_not_nil(exp, msg=nil)
-      opts[:backtrace] ||= caller
-      NilFailure.refute(exp, :message=>msg, :backtrace=>caller)
-    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

@@ -1,134 +0,0 @@
-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 @mesg if @mesg
-      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 exception.
-    #
-    #   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