assay 0.3.0 → 0.4.0

data/lib/assay/like_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'assertion'
+
+# LikeAssay defines an assertion for broad equality.
+#
+class LikeAssay < Assertion
+
+  register :like
+
+  #
+  # Test assertion for `#like?`.
+  #
+  def self.pass?(subject, criterion)
+    subject.like?(criterion)
+  end
+
+end
+

data/lib/assay/match_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'like_assay'
+
+#
+#
+# 
+class MatchAssay < LikeAssay
+
+  register :=~, :match
+
+  #
+  # Check assertion for `#=~` method.
+  #
+  def self.pass?(matcher, matchee)
+    matcher =~ matchee
+  end
+
+end

data/lib/assay/more_assay.rb

@@ -0,0 +1,18 @@
+require_relative 'compare_assay'
+
+# Compare assertion is used to test a comparision
+# made by `#>`.
+#
+class MoreAssay < CompareAssay
+
+  register :>, :more_than
+
+  #
+  # Check assertion using `#>` method call.
+  #
+  def self.pass?(subject, criterion)
+    subject > criterion
+  end
+
+end
+

data/lib/assay/more_equal_assay.rb

@@ -0,0 +1,25 @@
+require_relative 'compare_assay'
+
+# Compare assertion is used to test a comparision made by `#>=`.
+#
+# NOTE: We are taking some leeway here with the name of this class,
+# which ordinarily would be called `GreaterThanOrEqualAssay`.
+# However, such a name is a bit winded. The shortest name then,
+# without resorting to abbreviations, is _more-equal_, a monosyllabic
+# reading of the operator itself. Since it is ordinarily meaningless
+# to say something is "more equal" than something else, why not allow
+# it to be meaningful and save ourselves all that uneccessary verbage?
+#
+class MoreEqualAssay < CompareAssay
+
+  register :>=, :more_equal
+
+  #
+  # Check assertion using `#>=` method.
+  #
+  def self.pass?(subject, criterion)
+    subject >= criterion
+  end
+
+end
+

data/lib/assay/nil_assay.rb

@@ -0,0 +1,15 @@
+require_relative 'assertion'
+
+class NilAssay < Assertion
+
+  register :nil
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(subject)
+    subject.nil?
+  end
+
+end
+

data/lib/assay/nomatch_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'match_assay'
+
+# Ruby 1.9+ allows #!~ to redfined as it's own method, so a corresponding
+# assay is required to cover it.
+# 
+class NoMatchAssay < MatchAssay
+
+  register :!~, :nomatch
+
+  #
+  # Check no match assertion with `#!~` method.
+  #
+  def self.pass?(matcher, matchee)
+    matcher !~ matchee
+  end
+
+end

data/lib/assay/output_assay.rb

@@ -0,0 +1,35 @@
+require_relative 'assertion'
+
+# Assert that there is output, either from stdout or stderr.
+#
+#   OutputAssay.pass?(/foo/){ puts 'foo!' }  #=> true
+#
+class OutputAssay < Assertion
+
+  register :output
+
+  #
+  # Compare +match+ against $stdout and $stderr via `#===` method.
+  # 
+  # Note that $stdout and $stderr are temporarily reouted to StringIO
+  # objects and the results have any trailing newline chomped off.
+  #
+  def self.pass?(match, &block)
+    require 'stringio'
+
+    begin
+      stdout, stderr = $stdout, $stderr
+      newout, newerr = StringIO.new, StringIO.new
+      $stdout, $stderr = newout, newerr
+      yield  
+    ensure
+      $stdout, $stderr = stdout, stderr
+    end
+
+    newout, newerr = newout.string.chomp("\n"), newerr.string.chomp("\n")
+
+    match === newout || match === newerr
+  end
+
+end
+

data/lib/assay/path_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'assertion'
+
+# Assert the existance of a file with `File.file?` call.
+#
+class PathAssay < Assertion
+
+  register :path
+
+  #
+  # Check assertion using `File.exist?` method.
+  #
+  def self.pass?(path)
+    File.exist?(path)
+  end
+
+end
+

data/lib/assay/raise_assay.rb

@@ -0,0 +1,109 @@
+require_relative 'rescue_assay'
+
+#
+class RaiseAssay < RescueAssay
+
+  register :raised
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(*exceptions)
+    exceptions = [RuntimeError] if exceptions.empty?
+    begin
+      yield
+      false
+    rescue Exception => e
+      exceptions.any? do |x|
+        x.instance_of?(Module) ? x === e : e.class == x
+      end
+    end
+  end
+
+  #
+  # Check negated assertion.
+  #
+  def self.fail?(*exceptions)
+    exceptions = [RuntimeError] if exceptions.empty?
+    begin
+      yield
+      true
+    rescue Exception => e
+      !exceptions.any? do |x|
+        x.instance_of?(Module) ? x === e : e.class == x
+      end
+    end
+  end
+
+  # TODO: How to add `but got class` to message?
+  #       May have to override `#assert!` and `#refute!`.
+
+  #
+  #
+  #
+  def self.assert_message(*exceptions)
+    exp = exceptions.map{ |e| e.inspect }.join(' or ')
+    "raise #{exp}" #, but was #{err} instead."
+  end
+
+  #
+  #
+  #
+  def self.refute_message(*exceptions)
+    exp = exceptions.map{ |e| e.inspect }.join(' or ')
+    "! raise #{exp}" #, but was #{err} instead."
+  end
+
+=begin
+  #
+  #
+  #
+  def self.assert!(*exp) #:yeild:
+    options = (Hash === exp.last ? exp.pop : {})
+
+    exp = exp.first
+
+    begin
+      yield
+      test      = false
+      arguments = [exp]
+    rescue Exception => err
+      test      = (exp === err)
+      arguments = [exp, err]
+    end
+
+    message   = options[:message]   || pass_message(*arguments)
+    backtrace = options[:backtrace] || caller
+
+    if !test
+      fail self, message, backtrace
+    end
+  end
+
+  #
+  #
+  #
+  def self.refute!(*exp) #:yield:
+    options = (Hash === exp.last ? exp.pop : {})
+
+    #exp = exp.first
+
+    begin
+      yield
+      test      = true
+      arguments = exp
+    rescue Exception => err
+      test      = !exp.any?{ |e| e === err }
+      arguments = exp #+ [err]
+    end
+
+    message   = options[:message]   || fail_message(*arguments)
+    backtrace = options[:backtrace] || caller
+
+    if !test
+      fail self, message, backtrace
+    end
+  end
+=end
+
+end

data/lib/assay/rescue_assay.rb

@@ -0,0 +1,55 @@
+require_relative 'assertion'
+
+# Assert that a kind of exception class is rescued
+# from the execution of a block.
+#
+class RescueAssay < Assertion
+
+  register :rescue
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(*exceptions)
+    exceptions = [RuntimeError] if exceptions.empty?
+    begin
+      yield
+      false
+    rescue Exception => e
+      exceptions.any? do |x|
+        x === e
+      end
+    end
+  end
+
+  #
+  # Check negated assertion.
+  #
+  def self.fail?(*exceptions)
+    exceptions = [RuntimeError] if exceptions.empty?
+    begin
+      yield
+      true
+    rescue Exception => e
+      !exceptions.any? do |x|
+        x === e
+      end
+    end
+  end
+
+  # TODO: How to add `but got class` message to error?
+  #       May have to override #assert! and #refute! method.
+
+  #
+  def self.assert_message(*exceptions)
+    exp = exceptions.map{ |e| e.inspect }.join(' or ')
+    "raise #{exp}" #, but was #{err} instead."
+  end
+
+  #
+  def self.refute_message(*exceptions)
+    exp = exceptions.map{ |e| e.inspect }.join(' or ')
+    "! raise #{exp}" #, but was #{err} instead."
+  end
+
+end

data/lib/assay/respond_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'assertion'
+
+# Does an object #respond_to? a method call.
+#
+class RespondAssay < Assertion
+
+  register :respond_to
+
+  # Check assertion.
+  def self.pass?(reciever, method_name)
+    #flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
+    #obj, meth = meth, obj if flip
+    reciever.respond_to?(method_name)
+  end
+
+end
+

data/lib/assay/return_assay.rb

@@ -0,0 +1,46 @@
+require_relative 'execution_assay'
+
+# Assert that a block of code returns a specific result, also
+# fails if an error is raised in the block.
+#
+class ReturnAssay < ExecutionAssay
+
+  register :returns
+
+  #
+  # Check that a block returns a specific value comparing 
+  # the +returns+ argument and actual returned value with
+  # the `#==` operator.
+  #
+  def self.pass?(returns, *arguments)  #:yield:
+    begin
+      result = yield(*arguments)
+      returns == result
+    rescue Exception
+      false
+    end
+  end
+
+  #
+  # Check that a block does NOT return a specific value comparing 
+  # the +returns+ argument and actual returned value with
+  # the `#==` operator.
+  #
+  def self.fail?(returns, *arguments)  #:yield:
+    begin
+      result = yield(*arguments)
+      returns != result
+    rescue Exception
+      true
+    end
+  end
+
+  ##
+  ##
+  ##
+  #def self.assert_message(*arguments, &block)
+  #  "#{block}.call(*#{arguments.inspect})"
+  #end
+
+end
+

data/lib/assay/silent_assay.rb

@@ -0,0 +1,59 @@
+require_relative 'output_assay'
+
+# Assert that there is no output, either from stdout or stderr.
+#
+#   SilentAssay.pass?{ puts 'foo!' }  #=> false
+#
+class SilentAssay < OutputAssay
+
+  register :silent
+
+  #
+  # Compare +match+ against $stdout and $stderr via `#===` method.
+  # 
+  # Note that $stdout and $stderr are temporarily reouted to StringIO
+  # objects and the results have any trailing newline chomped off.
+  #
+  def self.pass?(&block)
+    require 'stringio'
+
+    begin
+      stdout, stderr = $stdout, $stderr
+      newout, newerr = StringIO.new, StringIO.new
+      $stdout, $stderr = newout, newerr
+      yield  
+    ensure
+      $stdout, $stderr = stdout, stderr
+    end
+
+    newout, newerr = newout.string.chomp("\n"), newerr.string.chomp("\n")
+
+    newout.empty? && newerr.empty?
+  end
+
+  # TODO: Assertable isn't dealing with no-argument assertions well,
+  #       see if this can be improved.
+
+  #
+  # Opposite of `SilentAssay.pass?`.
+  #
+  def self.fail?(&block)
+    ! pass?(&block)
+  end
+
+  #
+  #
+  #
+  def self.assert_message(*)
+    "unexpected output"
+  end
+
+  #
+  #
+  #
+  def self.refute_message(*)
+    "expected output"
+  end
+
+end
+