picotest 0.0.1

data/README

@@ -0,0 +1,177 @@
+= Picotest - simple reduced tests
+
+Picotest is a gem which allows to write complete test suites in a few lines, targeted primarily to test separated methods, algorithms or little snippets of code
+
+== Installation
+
+The install is as simple as execute the well-known gem install:
+
+sudo gem install picotest
+
+== Known Limitations & Issues
+
+* Reverse oracle test only can be compared using exact equals (see sqrt example)
+* Metaprogramming of input/output pairs are ugly
+* Oracle testing does not allow expectation test making difficult to debug failing tests
+* Complete lack of RDoc
+
+== Usage
+
+To use picotest you should write suites using suite method, each suite is defined by a hash and an optional
+description, the keys of the hash are used as input for the method and the corresponding values as expected output
+
+For example, to specify that the method receiving 1 should return 1, receiving 4 should return 2 and receiving 9 should return 3, use the following syntax:
+
+  suite(1 => 1, 4 => 2, 9 => 3)
+
+Or:
+
+  suite("integer sqrt", 1 => 1, 4 => 2, 9 => 3)
+
+After that, you should specify the test:
+
+  suite("integer sqrt", 1 => 1, 4 => 2, 9 => 3).test(Math.method(:sqrt))
+
+To run test, you should set the environment variable PICOTEST_RUN to 1
+
+=== Environment variables
+
+All environments are activated setting their value to 1, other values distinct from 1 will be ignored
+
+PICOTEST_RUN        enables the execution of test
+PICOTEST_REPORT     enables reports of test on standard output and disables Picotest::Fail exceptions when test fails
+PICOTEST_AUTOTEST   enables tests of picotest itself
+PICOTEST_FAIL       simulate failure of all tests, for picotest test purpose
+
+== Code Examples
+
+See samples directory under the gem root
+
+=== Example 1: basic usage of suite and test method
+
+  class X
+    def foo(data)
+      data.split(";")[2].to_f
+    end
+  end
+
+  suite( "aaa;xxx;1.0;999" => 1.0, ";;3.2" => 3.2).test X.new.method(:foo)
+
+=== Example 2: Input sets
+
+Both -2 and 2 should evaluate to 4 on lambda{|x|x*x}
+
+  suite(_set(-2,2) => 4).test lambda{|x|x*x}
+
+=== Example 3: Oracle testing
+
+Using a lambda as value on the hash can be used to specify a rule to validate output-input pairs, useful for oracle testing
+
+  suite(4 => lambda{|y,x| y*y == x}).test Math.method(:sqrt)
+
+=== Example 4: Oracle testing with input sets
+
+This time, the validation rule must considerate the imprecision of floats and check using a error margin
+
+  suite(_set(1,2,3,4,5) => lambda{|y,x| (y*y - x).abs<0.00001}).test Math.method(:sqrt)
+  suite(_set(*(1..100) ) => lambda{|y,x| (y*y - x).abs<0.00001}).test Math.method(:sqrt)
+
+=== Example 5: Reversed oracle
+
+When valid inputs can be generated from output (i.e. float 1.0 output correspond to string "aaa;xxx;1.0;" input)
+
+  class X
+    def foo(data)
+      data.split(";")[2].to_f
+    end
+  end
+
+  suite( lambda{|x| ";;#{x}"} => _set(*(1..20).map(&:to_f)) ).test X.new.method(:foo)
+
+=== Example 6: Testing methods of input objects
+
+  suite( "a b" => ["a","b"]).test :split
+  suite( lambda{|x|x.join " "} => _set(["a","b"], ["x","y","z","1"], ["aaa","bbb"]) ).test :split
+
+=== Example 7: Testing multiple argument inputs
+
+  class X
+    def sum(*x)
+      x.inject{|a,b| a+b}
+    end
+  end
+
+  suite( 1 => 1, [1,2] => 3, [1,2,3] => 6 ).test X.new.method(:sum)
+  suite(_set(*(1..100)) => lambda{|y,x| y == x},
+      _set([1,2],[3,4],[4,6],[5,6]) => lambda{|y,x1,x2| y == x1+x2},
+      _set([1,2,3],[3,4,5],[4,6,7],[5,6,7]) => lambda{|y,x1,x2,x3| y == x1+x2+x3}
+      ).test X.new.method(:sum)
+
+=== Example 8: Mocking instance variable
+
+  class X
+    def foo(data)
+      data.split(";")[@fieldno].to_f
+    end
+  end
+
+  suite(hash).test X.new.method(:foo).mock(:@fieldno => 2)
+
+=== Example 9: Mocking method on receiver object
+
+  class X
+    attr_accessor :fieldno
+    def foo(data)
+      data.split(";")[fieldno].to_f
+    end
+  end
+
+  suite(hash).test X.new.method(:foo).mock(:fieldno => 2)
+
+=== Example 10: Mock objects
+
+  class X
+    attr_accessor :another_object
+    def foo(data)
+      data.split(";")[another_object.fieldno].to_f
+    end
+  end
+
+  suite(hash).test X.new.method(:foo).mock(:another_object => mock(:fieldno => 2) )
+
+=== Example 11: Mocking method on receiver object
+
+  class X
+    attr_accessor :another_object
+    def foo(data)
+      another_object.invented_here_split(data,";")[@fieldno].to_f
+    end
+  end
+
+  # you can specify the implementatioin of methods using lambdas
+  suite(hash).test X.new.method(:foo).mock(
+    :another_object => mock(:invented_here_split => lambda{|str,sep| str.split(sep) }), 
+    :@fieldno => 2 )
+
+  # Since :split.to_proc is equivalent to lambda{|str,sep| str.split(sep) }, you can also use:
+  suite(hash).test X.new.method(:foo).mock(
+    :another_object => mock(:invented_here_split => :split.to_proc), 
+    :@fieldno => 2 )
+
+
+=== Example 12: Exceptions
+
+  class X
+    def foo(a)
+      raise ArgumentError unless a.kind_of? Numeric
+
+      a*2
+    end
+  end
+
+  suite(1 => 2, 2 => 4, 3 => 6, "00" => _raise(ArgumentError)).test(X.new.method(:foo))
+
+== Copying
+
+Copyright (c) 2012 Dario Seminara, released under the GPL License (see LICENSE)
+

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require "rspec/core/rake_task"
+
+spec = Gem::Specification.new do |s|
+  s.name = 'picotest'
+  s.version = '0.0.1'
+  s.author = 'Dario Seminara'
+  s.email = 'robertodarioseminara@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Test pico framework. One-line test suite'
+  s.homepage = "http://github.com/tario/picotest"
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ 'README' ]
+  s.files = Dir.glob("{samples,lib}/**/*") +[ 'LICENSE', 'AUTHORS', 'README', 'Rakefile', 'CHANGELOG' ]
+end
+
+desc 'Run tests'
+task :test do
+  ENV['PICOTEST_AUTOTEST'] = '1'
+  ENV['PICOTEST_REPORT'] = '1'
+  ENV['PICOTEST_RUN'] = '1'
+  require "picotest"
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new :rdoc do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'README'
+  rd.main = 'README'
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]
+
+

data/lib/picotest.rb

@@ -0,0 +1,27 @@
+=begin
+
+This file is part of the picotest project, http://github.com/tario/picotest
+
+Copyright (c) 2012 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+picotest is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+picotest is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with picotest.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "picotest/picomock"
+require "picotest/version"
+require "picotest/core"
+require "picotest/autotest"
+module Picotest
+end
+

data/lib/picotest/autotest.rb

@@ -0,0 +1,87 @@
+=begin
+
+This file is part of the picotest project, http://github.com/tario/picotest
+
+Copyright (c) 2012 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+picotest is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+picotest is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with picotest.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+# pico test testing himself
+require "picotest/autotest/samples"
+
+module Picotest
+
+if ENV['PICOTEST_AUTOTEST'] == '1'
+
+
+suite("suiteure should accept :test method", [] => lambda{|x| x.respond_to? :test}).test(method(:suite))
+
+suite("raise Fail when tested method raises Fail", 
+  [1] => _raise(Fail) ).test(lambda{|x|raise Fail})
+
+failing_suite = suite("always fails", [] => lambda{|x| false})
+suite("test should raise Fail when condition returns false", 
+  [lambda{}] => _raise(Fail) ).test(failing_suite.method(:test))
+
+suite("message of Fail should be 'Test fail: always fails' when expectation title is 'always fails'", 
+  [lambda{}] => _raise(Fail, "Test fail: always fails") ).test(failing_suite.method(:test))
+
+failing_suite = suite("unexpected message", [] => lambda{|x| false})
+message_suiteure = suite("Should raise Fail with expected message", [lambda{}] => _raise(Fail, "Test fail: expected message") )
+
+suite("wrong fail message should raise fail", [failing_suite.method(:test)] => _raise(Fail)).test message_suiteure.method(:test) 
+
+failing_suite = suite("always always fails", [] => lambda{|x| false})
+suite("message of Fail should be 'Test fail: always always fails' when expectation title is 'always always fails'", 
+  [lambda{}] => _raise(Fail, "Test fail: always always fails") ).test(failing_suite.method(:test))
+
+failing_suite = suite([]=>lambda{|x|false})
+suite("failing suite with lambda{|x|false} and without fail message should fail", [lambda{}]=>_raise(Fail)).
+  test(failing_suite.method(:test))
+
+passing_suite = suite("should not raise",[]=>lambda{|x|true})
+suite("passing suite with lambda{|x|true} should not fail", [lambda{}]=>_not_raise).
+  test(passing_suite.method(:test))
+
+passing_suite = suite([]=>lambda{|x|true})
+suite("passing suite with lambda{|x|true} and without fail message should not fail", [lambda{}]=>_not_raise).
+  test(passing_suite.method(:test))
+
+suite("numeric assert should not fail", 
+  [lambda{|x|x}] => _not_raise,
+  [lambda{|x|1}] => _not_raise,
+  [lambda{|x|0}] => _raise(Fail)).test(
+  suite([1] => 1).method(:test)
+  ) 
+
+suite("_set([1],[2],[3]) should pass with lambda{|x| [1,2,3].include? x}", 
+  [ lambda{|x| [1,2,3].include?(x) ? 4: nil} ] => _not_raise
+).test( suite(_set([1],[2],[3]) => 4).method(:test) )
+
+suite("_set([1],[2],[3]) should pass with lambda{|x| [1,2,3].include? x}", 
+  [ lambda{|x| [1,2,3].include?(x) ? 4: nil} ] => _not_raise
+).test( suite(_set(1,2,3) => 4).method(:test) )
+
+class X
+  def foo(*x)
+    @bar.foo(*x)
+  end
+end
+
+suite( 1 => 1, 2 => 4, 3 => 9).test( X.new.method(:foo).mock( :@bar => mock(:foo => lambda{|x|x*x} ) )) 
+
+end
+end
+

data/lib/picotest/autotest/samples.rb

@@ -0,0 +1,63 @@
+=begin
+
+This file is part of the picotest project, http://github.com/tario/picotest
+
+Copyright (c) 2012 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+picotest is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+picotest is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with picotest.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+module Picotest
+
+if ENV['PICOTEST_AUTOTEST'] == '1'
+# normal test (as you could do the test)
+suite("squared 1,2,3,4", [1] => 1, [2] => 4, [3] => 9, [4] => 16).test lambda{|x| x*x}
+suite("negative number elevated to 2",_set([1],[-1]) => 1, _set([2],[-2]) => 4, _set([3],[-3]) => 9, _set([4],[-4]) => 16).test lambda{|x| x*x}
+
+suite("sqrt of 1,4,9,16",[1] => 1, [4] => 2, [9] => 3, [16] => 4).test Math.method(:sqrt)
+
+suite("sqrt of pf 1,4,9,16,25", _set(1,4,9,16,25) => lambda{|y,x| y**2==x}).test Math.method(:sqrt)
+suite("sqrt of 1 to 20 elevated to 2", lambda{|x| x**2} => _set(*(1..20))).test Math.method(:sqrt)
+
+suite("sqrt of 1 to 100",_set(*(1..100)) => lambda{|y,x| (y**2 - x.to_f).abs < 0.000000005}).test Math.method(:sqrt)
+
+# all last four togheter
+
+suite("sqrt", [1] => 1, [4] => 2, [9] => 3, [16] => 4,
+      _set(1,4,9,16,25) => lambda{|y,x| y**2==x}, 
+      lambda{|x| x**2} => _set(*(1..20)),
+      _set(*(1..100)) => lambda{|y,x| y**2 - x.to_f < 0.000000005} ).test(Math.method(:sqrt))
+
+# picotest testing the test
+suite(
+  [lambda{|x|x*x}] => _not_raise,
+  [lambda{|x|x**2}] => _not_raise,
+  [lambda{|x| case x; when 1; 1; when 2; 4; when 3; 9; when 4; 16; end}] => _not_raise,
+  [lambda{|x| case x; when 1; 1; when 2; 4; when 3; 9; when 4; 15; end}] => _raise(Fail)
+  ).test(
+    suite([1] => 1, [2] => 4, [3] => 9, [4] => 16).method(:test)
+  )
+
+# same as the previous but using another syntax
+suite(
+  _set(
+    [lambda{|x|x*x}],[lambda{|x|x**2}], [lambda{|x| case x; when 1; 1; when 2; 4; when 3; 9; when 4; 16; end}]) => _not_raise,
+  [lambda{|x| case x; when 1; 1; when 2; 4; when 3; 9; when 4; 15; end}] => _raise(Fail)
+  ).test(
+    suite([1] => 1, [2] => 4, [3] => 9, [4] => 16).method(:test)
+  )
+
+end
+end
+

data/lib/picotest/core.rb

@@ -0,0 +1,231 @@
+=begin
+
+This file is part of the picotest project, http://github.com/tario/picotest
+
+Copyright (c) 2012 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+picotest is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+picotest is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with picotest.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+class Object
+  def to_test_proc
+    Picotest::ConstantTestProc.new(self)
+  end
+
+  def to_input_set
+    Picotest::InputSet.new([self])
+  end
+end
+
+class Proc
+  def to_test_proc
+    Picotest::ProcTestProc.new(self)
+  end
+end
+
+module Picotest
+  class ProcTestProc
+    attr_accessor :expectation_text
+
+    def initialize(inner_proc)
+      @inner_proc = inner_proc
+      @expectation_text = ""
+    end
+
+    def call(m,*i)
+      o = m.call(*i)
+
+      if i.size+1 == @inner_proc.arity
+        @inner_proc.call(o,*i)
+      elsif @inner_proc.arity == 1
+        @inner_proc.call(o)
+      else
+        raise RuntimeError, "wrong arity for lambda"
+      end
+    end
+  end
+
+  class ConstantTestProc
+    def initialize(const)
+      @const = const
+    end
+
+    def call(m,*i)
+      @const == m.call(*i)
+    end
+
+    def expectation_text
+      @const.inspect
+    end
+  end
+
+  class Fail < Exception
+  end
+
+  class InputSet
+    def initialize(array); @array = array; end
+
+    def to_input_set
+      self
+    end
+
+    def each(&blk)
+      @array.each(&blk)
+    end
+  end
+
+  class RaiseAssert
+    attr_reader :expectation_text    
+    def initialize(ext,&blk)
+      @blk = blk
+      @expectation_text = ext
+    end
+
+    def to_test_proc
+      self
+    end
+
+    def call(*x)
+      @blk.call(*x)
+    end
+  end
+
+  class Suite
+    def initialize(fail_message,fxtdata,position)
+      @fxtdata=fxtdata
+      @fail_message=fail_message
+      @position = position
+
+      @report = ENV["PICOTEST_REPORT"] == "1" ? true : false
+      @raise_fail = @report ? false : true
+      @run = ENV["PICOTEST_RUN"] == "1" ? true : false
+      @emulate_fail = ENV["PICOTEST_FAIL"] == "1" ? true : false
+    end
+
+    def test(m)
+      return unless @run
+
+      if m.instance_of? Method
+        if m.owner == Picotest::Suite
+          m.receiver.instance_eval{@raise_fail = true}
+          m.receiver.instance_eval{@emulate_fail = false}
+        end
+      end
+      m = m.to_proc
+
+      test_fail = false
+
+      @fxtdata.each do |k,o|
+        if k.respond_to? :to_proc
+          oracle = k.to_proc
+          o.to_input_set.each do|_exp_o|
+            i = oracle.call(_exp_o)
+            _o = m.call(*i)
+            if not _o == _exp_o or @emulate_fail
+              test_fail = true
+
+              if @raise_fail
+              raise Picotest::Fail,'Test fail: '+@fail_message
+              else
+
+              location = if m.respond_to?(:source_location)
+                m.source_location
+              end
+
+              print "fail #{@fail_message}. Expected output:#{_exp_o} , received:#{_o}
+  suite at #{@position}
+  test at #{caller[0]}
+  #{location ? "method location at "+location.join(":") : "" }
+"
+              end
+            end 
+          end
+        else
+          k.to_input_set.each do|i|
+            test_proc = o.to_test_proc
+            if not test_proc.call(m,*i) or @emulate_fail
+              test_fail = true
+
+              if @raise_fail
+              raise Picotest::Fail,'Test fail: '+@fail_message
+              else
+
+              location = if m.respond_to?(:source_location)
+                m.source_location
+              end
+
+              print "fail #{@fail_message}. Input: #{i.inspect}, Expected: #{test_proc.expectation_text}
+  suite at #{@position}
+  test at #{caller[0]}
+  #{location ? "method location at "+location.join(":") : "" }
+
+"
+              end
+            end
+          end
+        end
+      end
+
+      unless test_fail
+        print "Test sucessfull at #{caller[0]}\n" if @report
+      end
+
+    end
+  end
+
+  module GlobalMethods
+    def suite(*args)
+      if args.size==1
+        Suite.new("",args.first,caller[0])
+      else
+        Suite.new(args.first,args.last,caller[0])
+      end
+    end
+
+    def _set(*args)
+      InputSet.new(args)
+    end
+
+    def _not_raise
+      RaiseAssert.new("not raise exception") {|m,*i|
+        begin
+          m.call(*i)
+          true
+        rescue
+          false
+        end
+      }
+    end
+
+    def _raise(expected, expected_message = nil)
+      RaiseAssert.new("raise #{expected}") {|m,*i|
+        begin
+          m.call(*i)
+          false
+        rescue expected => e
+          if expected_message
+            e.message == expected_message
+          else
+            true
+          end
+        end
+      }
+    end
+  end
+end
+
+class Object
+  include Picotest::GlobalMethods
+end
+