assay 0.3.0 → 0.4.0

data/NOTICE.rdoc

@@ -1,18 +0,0 @@
-= COPYRIGHT NOTICES
-
-== Assay
-
-Copyright 2009 Thomas Sawyer
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-

data/lib/assay/assertions/compare_failure.rb

@@ -1,61 +0,0 @@
-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 @mesg if @mesg
-      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

@@ -1,80 +0,0 @@
-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 @mesg if @mesg
-      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, msg=nil)
-      DeltaFailure.assert(exp, act, delta, :message=>msg, :backtrace=>caller)
-    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, msg=nil)
-      opts[:backtrace] ||= caller
-      DeltaFailure.refute(exp, act, delta, :message=>msg, :backtrace=>caller)
-    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

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

@@ -1,100 +0,0 @@
-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 @mesg if @mesg
-      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, msg=nil)
-      EqualityFailure.assert(exp, act, :message=>msg, :backtrace=>caller)
-    end
-
-    # Passes if expected != actual
-    #
-    #  assert_not_equal 'some string', 5
-    #
-    def assert_not_equal(exp, act, msg=nil)
-       EqualityFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
-    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

data/lib/assay/assertions/execution_failure.rb

@@ -1,90 +0,0 @@
-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
-      return @mesg if @mesg
-      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(msg=nil, &blk)
-      ExecutionFailure.assert(:message=>msg, :backtrace=>caller, &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(msg=nil, &blk)
-      ExecutionFailure.refute(:message=>msg, :backtrace=>caller, &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

@@ -1,72 +0,0 @@
-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 @mesg if @mesg
-      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, msg=nil)
-      FalseFailure.assert(exp, :message=>msg, :backtrace=>caller)
-    end
-
-    # Passed if object is not +false+.
-    #
-    #   assert_not_false(false)
-    #
-    def assert_not_false(exp, msg=nil)
-      FalseFailure.refute(exp, :message=>msg, :backtrace=>caller)
-    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