picotest 0.0.1

data/lib/picotest/picomock.rb

@@ -0,0 +1,106 @@
+=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 Undo
+  def initialize(*data,&blk)
+    @blk = blk
+    @data = data
+  end
+
+  def undo
+    @blk.call(*@data)
+  end
+end
+
+class Method
+  def mock(options = {})
+    lambda{|*x|
+      undo = Array.new
+
+      begin
+
+        options.each do |k,v|
+          case k.to_s
+            when /^\@/
+              undo << Undo.new(receiver.instance_variable_get(k)) {|x| receiver.instance_variable_set(k,x) } 
+              receiver.instance_variable_set(k,v)
+            when /^\$/
+              undo << Undo.new(eval(k.to_s)) {|x| eval("#{k.to_s} = x") } 
+              eval("#{k.to_s} = v")
+            else
+              undo << Undo.new {
+                eval "
+                  class << receiver
+                    remove_method :#{k}
+                  end
+                "
+              }
+
+              if v.respond_to? :call
+                receiver.define_singleton_method(k) do |*x|
+                  v.call(*x)
+                end
+              else
+                receiver.define_singleton_method(k) do |*x|
+                  v
+                end
+              end
+          end
+        end
+
+        call(*x)
+
+      ensure
+        undo.each &:undo
+      end
+    }
+  end
+end
+
+class Class
+  def new_mock(options = {})
+    mock(self,options)
+  end
+end
+
+def mock(*args)
+  options = args.select{|x| Hash === x }.inject{|x,y| x.merge(y) } || {}
+  klass = args.find{|x| Class === x} || Object
+  o = klass.new
+  options.each do |k,v|
+    case k.to_s
+      when /^\@/
+        o.instance_variable_set(k,v)
+      else
+        if v.respond_to? :call
+          o.define_singleton_method(k) do |*x|
+            v.call(*x)
+          end
+        else
+          o.define_singleton_method(k) do |*x|
+            v
+          end
+        end
+    end
+  end
+
+  o
+end
+

data/lib/picotest/version.rb

@@ -0,0 +1,3 @@
+module Picotest
+  VERSION = "0.0.1"
+end

data/samples/sample1.rb

@@ -0,0 +1,46 @@
+require "picotest"
+
+suite( "a b" => ["a","b"]).test :split
+suite( lambda{|x|x.join " "} => _set(["a","b"], ["x","y","z","1"], ["aaa","bbb"]) ).test :split
+
+class X
+  def foo(data)
+    data.split(";")[2].to_f
+  end
+end
+
+suite( "aaa;xxx;1.0;999" => 1.0, ";;3.2" => 3.2,
+        lambda{|x| ";;#{x}"} => _set(*(1..20).map(&:to_f)),
+        lambda{|x| "aaa;xxx;#{x};111"} => _set(*(1..20).map(&:to_f))
+        ).test X.new.method(:foo)
+
+suite(_set(-2,2) => 4).test lambda{|x|x*x}
+suite(lambda{|x|x*x} => 2).test Math.method(:sqrt)
+suite(4 => lambda{|y,x| y*y == x}).test Math.method(:sqrt)
+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)
+
+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(6,[1,5],[2,4],[3,3],[4,2],[5,1]) => 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)
+
+
+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))
+

data/samples/sample2.rb

@@ -0,0 +1,55 @@
+require "picotest"
+# mocking sample
+
+class X
+  def foo(data)
+    data.split(";")[@fieldno].to_f
+  end
+end
+
+s = suite( "aaa;xxx;1.0;999" => 1.0, ";;3.2" => 3.2,
+        lambda{|x| ";;#{x}"} => _set(*(1..20).map(&:to_f)),
+        lambda{|x| "aaa;xxx;#{x};111"} => _set(*(1..20).map(&:to_f)) )
+
+# to mock instance variable use mock method with a hash
+s.test X.new.method(:foo).mock(:@fieldno => 2)
+
+class X
+  attr_accessor :fieldno
+  def foo(data)
+    data.split(";")[fieldno].to_f
+  end
+end
+
+# it also can be use to mock method on the object owner of the method being tested
+s.test X.new.method(:foo).mock(:fieldno => 2)
+
+
+class X
+  attr_accessor :another_object
+  def foo(data)
+    data.split(";")[another_object.fieldno].to_f
+  end
+end
+
+# you can return mock objects using mock method again
+s.test X.new.method(:foo).mock(:another_object => mock(:fieldno => 2) )
+
+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
+s.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:
+s.test X.new.method(:foo).mock(
+  :another_object => mock(:invented_here_split => :split.to_proc), 
+  :@fieldno => 2 )
+
+

data/samples/sample3.rb

@@ -0,0 +1,23 @@
+require "picotest"
+# mocking sample for especial classes
+
+class X
+  def foo(a)
+    l = bar
+    raise RuntimeError unless l.instance_of? Proc
+    l.call(a)+1
+  end
+end
+
+s = suite(0 => 1, 1 => 3, 2 => 5, 3 => 7)
+
+# to mock a method returning lambda, you should use nested lambdas
+
+s.test X.new.method(:foo).mock(:bar => 
+  lambda{ # this lambda represents the mock of bar method
+    lambda{|x| # this is the lambda returned by the fake bar
+      x*2
+    }
+  }
+ )
+

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: picotest
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dario Seminara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-02 00:00:00.000000000Z
+dependencies: []
+description: 
+email: robertodarioseminara@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- samples/sample2.rb
+- samples/sample1.rb
+- samples/sample3.rb
+- lib/picotest.rb
+- lib/picotest/core.rb
+- lib/picotest/autotest.rb
+- lib/picotest/version.rb
+- lib/picotest/picomock.rb
+- lib/picotest/autotest/samples.rb
+- LICENSE
+- AUTHORS
+- README
+- Rakefile
+- CHANGELOG
+homepage: http://github.com/tario/picotest
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Test pico framework. One-line test suite
+test_files: []