assay 0.3.0 → 0.4.0

data/lib/assay/stderr_assay.rb

@@ -0,0 +1,30 @@
+require_relative 'output_assay'
+
+# Assert that there is output $stderr.
+#
+#   StderrAssay.pass?(/foo/){ $stderr.puts 'foo!' }  #=> true
+#
+class StderrAssay < OutputAssay
+
+  register :stderr
+
+  #
+  # Check assertion via `#===` method.
+  #
+  def self.pass?(match, &block)
+    require 'stringio'
+
+    begin
+      stderr  = $stderr
+      newerr  = StringIO.new
+      $stderr = newerr
+      yield  
+    ensure
+      $stderr = stderr
+    end
+
+    match === newerr.string.chomp("\n")
+  end
+
+end
+

data/lib/assay/stdout_assay.rb

@@ -0,0 +1,30 @@
+require_relative 'output_assay'
+
+# Assert that there is output, either from stdout or stderr.
+#
+#   StdoutAssay.pass?(/foo/){ puts 'foo!' }  #=> true
+#
+class StdoutAssay < OutputAssay
+
+  register :output
+
+  #
+  # Check assertion via `#===` method.
+  #
+  def self.pass?(match, &block)
+    require 'stringio'
+
+    begin
+      stdout  = $stdout
+      newout  = StringIO.new
+      $stdout = newout
+      yield
+    ensure
+      $stdout = stdout
+    end
+
+    match === newout.string.chomp("\n")
+  end
+
+end
+

data/lib/assay/throw_assay.rb

@@ -0,0 +1,89 @@
+require_relative 'execution_assay'
+
+# Assertion for catching specific throws.
+#
+class ThrowAssay < ExecutionAssay
+
+  register :throw
+
+  # TODO: Is it possible to catch _any_ type of throw? If so make the
+  #       argument optional for that.
+
+  # Passes if the block throws given symbol.
+  #
+  #   ThrowAssay.pass? :done do
+  #     throw :done
+  #   end
+  #
+  # If no symbol is given than passes if any is thrown.
+  # But note that in `#assert!`, the symbol must be `nil`
+  # rather than not given.
+  #
+  def self.pass?(symbol=nil) #:yield:
+    pass = true
+    if symbol
+      catch(symbol) do
+        begin
+          yield
+        rescue ArgumentError => err     # 1.9 exception
+          #msg += ", not #{err.message.split(/ /).last}"
+        rescue NameError => err         # 1.8 exception
+          #msg += ", not #{err.name.inspect}"
+        end
+        pass = false
+      end
+    else
+      begin
+        yield
+        pass = false
+      rescue ArgumentError => error
+        pass = false if /\Auncaught throw (.+)\z/ !~ error.message
+      end
+    end
+    pass
+  end
+
+  # Passes if the block does not throw given +symbol+.
+  #
+  #   ThrowAssay.fail? :done do
+  #     throw :chimp
+  #   end
+  #
+  # If no symbol is given then passes if nothing is thrown.
+  # But note that in `#refute!`, the symbol must be `nil`
+  # rather than not given.
+  #
+  def self.fail?(symbol=nil) #:yield:
+    if symbol
+      pass = false
+      catch(symbol) do
+        begin
+          yield
+        rescue ArgumentError => err     # 1.9 exception
+          #msg += ", not #{err.message.split(/ /).last}"
+        rescue NameError => err         # 1.8 exception
+          #msg += ", not #{err.name.inspect}"
+        end
+        pass = true
+      end
+    else
+      pass = false
+      begin
+        yield
+        pass = true
+      rescue ArgumentError => error
+        pass = true if /\Auncaught throw (.+)\z/ !~ error.message
+      end
+    end
+    pass
+  end
+
+  #
+  #
+  #
+  def self.assert_message(symbol)
+    s = symbol.inspect
+    "throw #{s}"
+  end
+
+end

data/lib/assay/true_assay.rb

@@ -0,0 +1,20 @@
+require_relative 'boolean_assay'
+
+# Comparison assertion for TrueClass.
+#
+#   TrueAssay.pass?(true) #=> true
+#   TrueAssay.fail?(true) #=> false
+#   TrueAssay.pass?(1)    #=> false
+#
+class TrueAssay < BooleanAssay
+
+  register :true
+
+  #
+  # Check assertion using `#true?` method.
+  #
+  def self.pass?(subject)
+    subject.true?  #TrueClass === subject
+  end
+
+end

data/lib/assay/unequal_assay.rb

@@ -0,0 +1,37 @@
+require_relative 'equal_assay'
+
+# UnequalAssay compares objects with `#!=` operator. Yes, as of Ruby 1.9
+# the `!=` is a redefinable method, and as such, we need a separate
+# assay to cover it.
+#
+class UnequalAssay < EqualAssay
+
+  register :!=, :unequal
+
+  #
+  # Check assertion using `#!=` method.
+  #
+  def self.pass?(subject, criterion)
+    subject != criterion
+  end
+
+  #
+  # Failed assertion message.
+  #
+  def self.assert_message(subject, criterion)
+    a = subject.inspect
+    b = criterion.inspect
+  
+    if a.size > SIZE_LIMIT or b.size > SIZE_LIMIT
+      if $ansi
+        d = ANSI::Diff.new(a, b)
+        a, b = d.diff1, d.diff2  # *d.to_a
+      end
+      "a != b\na) #{a}\nb) #{b}"
+    else
+      "#{a} != #{b}"
+    end
+  end
+
+end
+

data/lib/assay/within_assay.rb

@@ -0,0 +1,39 @@
+require_relative 'compare_assay'
+
+# TODO: Support Range for Delta comparisons.
+
+#
+class WithinAssay < CompareAssay
+
+  register :within
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(subject, criterion, delta)
+    if [subject, criterion, delta].all?{ |v| Numeric === v }
+      a, b, d = subject.to_f, criterion.to_f, delta.to_f
+    else
+      a, b, d = subject, criterion, delta
+    end
+
+    (b - d) <= a && (b + d) >= a
+  end
+
+  #
+  # Failed assertion message.
+  #
+  def self.assert_message(subject, criterion, delta)
+    a = subject.inspect
+    b = criterion.inspect
+    d = delta.inspect
+
+    if [a, b, d].any?{ |e| e.size > SIZE_LIMIT }
+      "b - d <= a <= b + d\na) #{a}\nb) #{b}\nd) #{d}"
+    else
+      "#{b} - #{d} <= #{a} <= #{b} + #{d}"
+    end
+  end
+
+end
+

data/test/case_compare_assay.rb

@@ -0,0 +1,59 @@
+covers 'assay/compare_assay'
+
+testcase CompareAssay do
+
+  class_method :pass? do
+
+    test do
+      assert CompareAssay.pass?(1, 1,  0)
+      assert CompareAssay.pass?(1, 2, -1)
+      assert CompareAssay.pass?(2, 1,  1)
+
+      refute CompareAssay.pass?(1, 1,  1)
+      refute CompareAssay.pass?(1, 1, -1)
+    end
+
+  end
+
+  class_method :fail? do
+
+    test do
+      assert CompareAssay.fail?(1, 1,  1)
+      assert CompareAssay.fail?(1, 1, -1)
+
+      refute CompareAssay.fail?(1, 1,  0)
+      refute CompareAssay.fail?(1, 2, -1)
+      refute CompareAssay.fail?(2, 1,  1)
+    end
+
+  end
+
+  class_method :assert! do
+
+    test do
+      CompareAssay.assert!(1, 1, 0)
+    end
+
+    test do
+      expect CompareAssay do
+        CompareAssay.assert!(1, 1, 1)
+      end
+    end
+
+  end
+
+  class_method :refute! do
+
+    test do
+      CompareAssay.refute!(1, 2, 0)
+    end
+
+    test do
+      expect CompareAssay do
+        CompareAssay.refute!(1, 1, 0)
+      end
+    end
+
+  end
+
+end

data/test/case_empty_assay.rb

@@ -0,0 +1,51 @@
+covers 'assay/empty_assay'
+
+testcase EmptyAssay do
+
+  class_method :pass? do
+
+    test do
+      assert EmptyAssay.pass?([])
+      refute EmptyAssay.pass?([1])
+    end
+
+  end
+
+  class_method :fail? do
+
+    test do
+      refute EmptyAssay.fail?([])
+      assert EmptyAssay.fail?([1])
+    end
+
+  end
+
+  class_method :assert! do
+
+    test do
+      EmptyAssay.assert!([])
+    end
+
+    test do
+      expect EmptyAssay do
+        EmptyAssay.assert!([1])
+      end
+    end
+
+  end
+
+  class_method :refute! do
+
+    test do
+      EmptyAssay.refute!([1])
+    end
+
+    test do
+      expect EmptyAssay do
+        EmptyAssay.refute!([])
+      end
+    end
+
+  end
+
+end

data/test/case_equal_assay.rb

@@ -0,0 +1,53 @@
+covers 'assay/equal_assay'
+
+testcase EqualAssay do
+
+  class_method :pass? do
+
+    test do
+      assert EqualAssay.pass?(1, 1)
+      assert EqualAssay.pass?(1, 1.0)
+      refute EqualAssay.pass?(1, 2)
+    end
+
+  end
+
+  class_method :fail? do
+
+    test do
+      refute EqualAssay.fail?(1, 1)
+      refute EqualAssay.fail?(1, 1.0)
+      assert EqualAssay.fail?(1, 2)
+    end
+
+  end
+
+  class_method :assert! do
+
+    test do
+      EqualAssay.assert!(1, 1)
+    end
+
+    test do
+      expect EqualAssay do
+        EqualAssay.assert!(1, 2)
+      end
+    end
+
+  end
+
+  class_method :refute! do
+
+    test do
+      EqualAssay.refute!(1, 2)
+    end
+
+    test do
+      expect EqualAssay do
+        EqualAssay.refute!(1, 1)
+      end
+    end
+
+  end
+
+end

data/test/case_equality_assay.rb

@@ -0,0 +1,55 @@
+covers 'assay/equality_assay'
+
+testcase EqualityAssay do
+
+  class_method :pass? do
+
+    test do
+      assert EqualityAssay.pass?(1, 1)
+
+      refute EqualityAssay.pass?(1, 1.0)
+      refute EqualityAssay.pass?(1, 2)
+    end
+
+  end
+
+  class_method :fail? do
+
+    test do
+      refute EqualityAssay.fail?(1, 1)
+
+      assert EqualityAssay.fail?(1, 1.0)
+      assert EqualityAssay.fail?(1, 2)
+    end
+
+  end
+
+  class_method :assert! do
+
+    test do
+      EqualityAssay.assert!(1, 1)
+    end
+
+    test do
+      expect EqualityAssay do
+        EqualityAssay.assert!(1, 2)
+      end
+    end
+
+  end
+
+  class_method :refute! do
+
+    test do
+      EqualityAssay.refute!(1, 1.0)
+    end
+
+    test do
+      expect EqualityAssay do
+        EqualityAssay.refute!(1, 1)
+      end
+    end
+
+  end
+
+end