assay 0.2.0

data/lib/assay/assertions/execution_failure.rb

@@ -0,0 +1,91 @@
+require 'assay/assertion'
+
+module Assay
+
+  # Assert that a block of coded executes without error.
+  #
+  # ExecutionFailure is also the base class of the other
+  # block-executing assertion classes.
+  class ExecutionFailure < Assertion
+    #
+    def self.assertion_name
+      :execution
+    end
+
+    # Check assertion.
+    def self.pass?(_=nil, &block)
+      begin
+        block.call
+        true
+      rescue Exception
+        false
+      end
+    end
+
+    # Check negated assertion.
+    def self.fail?(_=nil, &block)
+      begin
+        block.call
+        false
+      rescue Exception
+        true
+      end
+    end
+
+    #
+    def to_s
+      if @_negated
+        "Expected procedure to raise an exception"
+      else
+        "Expected procedure to execute successfully"
+      end
+    end
+
+  end
+
+
+  module Assertives
+    # Passes if the block yields successfully.
+    #
+    # assert_executes "Couldn't do the thing" do
+    #   do_the_thing
+    # end
+    #
+    def assert_executes(opts={}, &blk)
+      opts[:backtrace] ||= caller
+      ExecutionFailure.assert(opts, &blk)
+    end
+
+    # Passes if the block does not yield successfully.
+    #
+    # assert_not_executes "Couldn't do the thing" do
+    #   do_the_thing
+    # end
+    #
+    def assert_not_executes(opts={}, &blk)
+      opts[:backtrace] ||= caller
+      ExecutionFailure.refute(opts, &blk)
+    end
+  end
+
+
+  module Matchers
+    # TODO: Reasonable matcher for ExectuionFailure ?
+    #
+    #
+    #   proc.assert is_executed(*args)
+    #
+    def is_executed(&block)
+      ExecutionFailure.to_matcher(&block)
+    end
+
+    #
+    #
+    #   proc.should be_executed(*args)
+    #
+    def be_extecuted(&block)
+      ExecutionFailure.to_matcher(&block)
+    end
+  end
+
+end

data/lib/assay/assertions/false_failure.rb

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

data/lib/assay/assertions/identity_failure.rb

@@ -0,0 +1,86 @@
+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 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, opts={})
+      opts[:backtrace] ||= caller
+      IdentityFailure.assert(exp, act, opts)
+    end
+
+    # Passes if ! actual .equal? expected
+    #
+    #   assert_not_identical(Object.new, Object.new)
+    #
+    def assert_not_identical(exp, act, opts={})
+      opts[:backtrace] ||= caller
+      IdentityFailure.refute(exp, act, opts)
+    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

@@ -0,0 +1,77 @@
+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 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, opts={})
+      opts[:backtrace] ||= caller
+      InstanceFailure.assert(cls, obj, opts)
+    end
+
+    # Passes if object .instance_of? klass
+    #
+    #   assert_instance_of(String, 'foo')
+    #
+    def refute_instance_of(cls, obj, opts={})
+      opts[:backtrace] ||= caller
+      InstanceFailure.refute(cls, obj, opts)
+    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

@@ -0,0 +1,80 @@
+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 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, opts={})
+      opts[:backtrace] ||= caller
+      KindFailure.assert(cls, obj, opts)
+    end
+
+    # Passes if object .kind_of? klass
+    #
+    #   assert_not_kind_of(Object, 'foo')
+    #
+    def refute_kind_of(cls, obj, opts={})
+      KindFailure.refute(cls, obj, opts)
+    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

@@ -0,0 +1,86 @@
+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 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, opts={})
+      opts[:backtrace] ||= caller
+      MatchFailure.assert(exp, act, opts)
+    end
+
+    # Passes if regexp !~ string
+    #
+    #   refute_match(/two/, 'one 2 three')
+    #
+    def refute_match(exp, act, opts={})
+      opts[:backtrace] ||= caller
+      MatchFailure.refute(exp, act, opts)
+    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