section9-unittest 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Your Name all rights reserved
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,166 @@
+# section9/unittest.rb README
+
+Release: 0.0.1
+
+
+## Overview
+
+section9/unittest.rb is an extension library for Test::Unit, supporting both 1.8 and 1.9.
+
+* describe() and it() are available.
+** before(), after(), subject() are NOT supported.
+* verify_() helps to write assertion easily.
+
+## Examples:
+
+Example:
+
+	require 'test/unit'
+	require 'section9/unittest'
+	
+	class ExampleTest < TC   # or Section9::UnitTest::TestCase
+	  describe "Array" do
+	    describe "#collect()" do
+	      it "collects values for each item" do
+	        actual = [10, 20, 30].collect {|x| x + 1}
+	        verify_(actual) == [11, 21, 31]
+	        ## or assert_xxx() are available
+	        assert_equal([11, 21, 31], actual)
+	      end
+	    end
+	  end
+	end
+
+
+Assertions:
+
+	verify_(actual) == expected     # same as assert_equal(expected, actual)
+	verify_(actual) != expected     # same as assert_not_equal(expected, actual)  # for Ruby1.9
+	verify_(actual) >  expected     # same as assert_operator(actual, :>,  expected)
+	verify_(actual) >= expected     # same as assert_operator(actual, :>=, expected)
+	verify_(actual) <  expected     # same as assert_operator(actual, :<,  expected)
+	verify_(actual) <= expected     # same as assert_operator(actual, :>=  expected)
+	verify_(actual) =~ expected     # same as assert_match(expected, actual)
+	verify_(actual) !~ expected     # same as assert_no_match(expected, actual)  # for Ruby 1.9
+	verify_(act).in_delta?(exp, delta) # same as assert_in_delta(exp, act, delta)
+	verify_(actual).nil?            # same as assert_nil(actual)
+	verify_(actual).same?(expected) # same as assert_same(expected, actual)
+	verify_(actual).kind_of?(klass) # same as assert_kind_of(klass, actual)
+	verify_(actual).instance_of?(klass) # same as assert_instance_of(klass, actual)
+	
+	verify_(proc {...}).raise?(klass, errmsg)
+	                                # same as ex = assert_raise(klass) {...};
+	                                #         assert_equal(errmsg, ex.msg) if errmsg.is_a?(String)
+	                                #         assert_match(errmsg, ex.msg) if errmsg.is_a?(Regexp)
+
+
+Any boolean method can be assertion:
+
+	verify_(actual).empty?          # same as assert actual.empty? == true
+	verify_(actual).blank?          # same as assert actual.blank? == true
+	verify_(actual).end_with?(arg)  # same as assert actual.end_with?(arg) == true
+
+
+Negative assertion:
+
+	## you should use '.NOT ==' and '.NOT =~instead of '!=' and '!~' on Ruby 1.8,
+	## because 1.8 doesn't allow to override '!=' nor '!~' operators.
+	verify_(1+1).NOT == 3           # same as assert_not_equal(3, 1+1)
+	verify_("SOS").NOT =~ /\d+/     # same as assert_no_match(/\d+/, "SOS")
+	verify_(proc {...}).NOT.raise?
+	                                # same as assert_nothing_raised {...}
+
+
+Original assertion:
+
+	verify_(path).file_exist?       # same as assert File.file?(path)
+	verify_(path).dir_exist?        # same as assert File.dir?(path)
+	verify_(path).NOT.exist?        # same as assert ! File.exist?(path)
+	verify_(recorder).called?(...)  # see the next section
+
+
+Helper method 'at_exit()' registers block which is called in teardown() method:
+
+	class Example_TC < TC
+	  it "is an example to remove temporary file automatically" do
+	    File.open("tmp.txt", 'w') {|f| f.write("SOS") }
+	    at_exit { File.unlink("tmp.txt") }   # register block
+	    verify_(File.read("tmp.txt")) == "SOS"
+	  end
+	end
+
+
+Helper method 'tmp()' returns Section::Tmp object (see the next section):
+
+	class Example_TC < TC
+	  it "is an example to capture $stdout" do
+	    ## create new StringIO object and set it to $stdout
+	    sout = tmp.stdout()
+	    ## print something
+	    puts "SOS"
+	    ## do test
+	    verify_(sout.string) == "SOS\n"
+	    ## $stdout is recovered automatically in teardown() method.
+	  end
+	end
+
+
+Helper method 'recorder()' returns Section::Recorder object (see the next section):
+
+	class Calc
+	  def total(*nums)
+	    return nums.sum
+	  end
+	  def average(*nums)
+	    return total(nums).to_f / nums.length
+	  end
+	end
+	class Example_TC < TC
+	  it "is an example to record method calls" do
+	    rc = recorder()                    # create recorder object
+	    calc = Calc()
+	    rc.record(calc, :total, :average)  # register methods to record
+	    n = calc.average(10, 20, 9)
+	    verify_(n) == 13
+	    ## check method call
+	    verify_(rc[0]).called?(:obj=>calc, :name=>:average, :args=>[10, 20, 9], :ret=>13)
+	    verify_(rc[1]).called?(:obj=>calc, :name=>:total, :args=>[10, 20, 9], :ret=>39)
+	    ## or
+	    verify_(rc[0]).called?([calc, :average, [10, 20, 9], 13])
+	    verify_(rc[1]).called?([calc, :total, [10, 20, 9], 39])
+	    ## or
+	    verify_(rc[0].obj)  == calc
+	    verify_(rc[0].name) == :average
+	    verify_(rc[0].args) == [10, 20, 9]
+	    verify_(rc[0].ret)  == 13
+	  end
+	end
+
+
+These helper methods are defined in TC (== Section9::UnitTest::TestCase) class,
+therefore you can use them in 'test_xxx()' methods:
+
+	class Example_TC < TC
+	  def test_1
+	    verify_(1+1) == 2
+	    at_exit { ... }
+	    sout = tmp.stdout()
+	    rc = record()
+	  end
+	end
+
+
+## History
+
+* 0.1.0
+** public release
+
+
+## License
+
+$License: MIT License $
+
+
+## Copyright
+
+$Copyright: copyright(c) 2011 kuwata-lab.com all rights reserved $

data/lib/section9/unittest.rb

@@ -0,0 +1,455 @@
+###
+### $Release: 0.0.1 $
+### $Copyright: copyright(c) 2011 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+require 'test/unit'
+require 'section9/tmp'
+
+
+module Section9
+  module UnitTest
+  end
+end
+
+
+module Section9::UnitTest
+
+
+  ASSERTION = defined?(MiniTest) ? MiniTest::Assertion : Test::Unit::AssertionFailedError  # :nodoc:
+
+
+  class TestCase < Test::Unit::TestCase
+
+    ##
+    ## 'describe' and 'it'
+    ##
+    def self.describe(obj, &block)
+      (@__describes ||= []) << obj
+      yield
+    ensure
+      @__describes.pop
+    end unless self.respond_to?(:describe)
+
+    def self.it(desc, &block)
+      @__count ||= 0
+      @__count += 1
+      arr = @__describes
+      desc = "[#{arr.join(' > ')}] #{desc}" if arr && ! arr.empty?
+      method_name = "test_%03d: %s" % [@__count, desc]
+      define_method(method_name, block)
+    end unless self.respond_to?(:it)
+
+    ##
+    ## shortcut for assertion methods
+    ##
+    def verify_(actual=nil, &block)
+      location = caller(1).first
+      vo = VerifyObject.new(self, actual, location, &block)
+      __register(vo)
+      vo
+    end
+
+    def __register(vo)                      #:nodoc:
+      (@__not_yet ||= {})[vo.__id__] = vo
+    end
+
+    def __unregister(vo)                    #:nodoc:
+      (@__not_yet ||= {}).delete(vo.__id__)
+    end
+
+    def __clear_registered                  #:nodoc:
+      @__not_yet.clear if @__not_yet
+    end
+
+    def __report_registered                 #:nodoc:
+      return unless @__not_yet
+      @__not_yet.each_value do |vo|
+        $stderr.write "** warning: verify() is called but not tested yet (at #{vo.location})\n"
+      end
+      @__not_yet.clear
+      @__not_yet = nil
+    end
+    private :__report_registered
+
+    def teardown
+      super
+      __report_registered()
+    end
+
+    ##
+    ## assertions
+    ##
+    def assert_block(*msgs)        # re-define for Ruby <= 1.9.1
+      assert yield, *msgs
+    end if defined?(MiniTest)
+
+    def assert_not_kind_of(klass, obj, msg="")
+      #errmsg = build_message("<?>\nexpected not to be kind_of\\?\n<?> but was\n<?>.", obj, klass, obj.class)
+      errmsg = "<#{obj.inspect}>\nexpected not to be kind_of?\n<#{klass}> but was\n<#{obj.class}>."
+      assert_block(errmsg) { ! obj.kind_of?(klass) }
+    end
+
+    def assert_not_instance_of(klass, obj, msg="")
+      #errmsg = build_message(msg, "<?>\nexpected not to be instance_of\\?\n<?> but was.", obj, klass)
+      errmsg = "<#{obj.inspect}>\nexpected not to be instance_of?\n<#{klass}> but was."
+      assert_block(errmsg) { ! obj.instance_of?(klass) }
+    end
+
+    def assert_not_in_delta(expected, actual, delta, msg="")
+      errmsg = "<#{expected.inspect}> and\n<#{actual.inspect}> expected to be without\n<0.0001> of each other."
+      assert_block(errmsg) { (expected - actual).abs > delta }
+    end
+
+    def assert_not_respond_to(actual, method, msg="")
+      #errmsg = build_message(msg, "Expected ? not to respond to ?.", actual, method.to_s.intern)
+      errmsg = "Expected #{actual.inspect} not to respond to #{method.inspect}."
+      assert_block(errmsg) { ! actual.respond_to?(method) }
+    end
+
+    def assert_nothing_thrown(msg="")
+      errcls = RUBY_VERSION >= "1.9" ? ArgumentError : NameError
+      yield
+      assert_block("Expected nothing to be thrown") { true }
+    rescue errcls => ex
+      #errmsg = build_message(msg, "nothing should be thrown but #{ex.message}")
+      errmsg = "nothing should be thrown but #{ex.message}"
+      assert_block(errmsg) { false }
+    end
+
+    ## ignore unnecessary warning
+    def default_test
+      super if self.class.name != 'Section9::UnitTest::TestCase'
+    end
+
+  end
+
+
+  class VerifyBaseObject
+
+    DEPTH = defined?(MiniTest) ? 3 : 2    #:nodoc:
+
+    private
+
+    def _wrap
+      @testcase.__unregister(self)
+      begin
+        yield
+      rescue ASSERTION => ex
+        ex.set_backtrace(caller(DEPTH))
+        raise ex
+      end
+    end
+
+    def _method_missing(expected, method_name, *args)
+      method_name.to_s =~ /\?$/  or
+        raise NoMethodError.new("undefined method `#{method_name}' for verify()#{expected ? '' : '.NOT'} object.")
+      begin
+        result = @actual.__send__(method_name, *args)
+      rescue NoMethodError => ex
+        ex.set_backtrace(caller(2))
+        raise ex
+      end
+      if result == expected
+        @testcase.assert true
+      elsif result == ! expected
+        msg = "$actual.#{method_name}() == #{expected}: failed.\n"\
+              "  actual:   #{@actual.inspect}"
+        msg << "\n  args:     #{args.inspect[1..-2]}" unless args.empty?
+        @testcase.flunk msg
+      else
+        raise ArgumentError.new("#{@actual.class.name}##{method_name}(): expected to return true or false, but returned #{result.inspect}.")
+      end
+    end
+
+    undef_method *(instance_methods.grep(/\?\z/) - [:equal?, "equal?"])
+
+  end
+
+
+  class VerifyObject < VerifyBaseObject
+
+    def initialize(testcase, actual=nil, location=nil, &block)
+      @testcase = testcase
+      @actual = actual
+      @block = block
+      @location = location
+    end
+    attr_accessor :location
+
+    def NOT
+      @testcase.__unregister(self)
+      location = caller(1).first
+      vo = VerifyNotObject.new(@testcase, @actual, location, &@block)
+      @testcase.__register(vo)
+      return vo
+    end
+
+    def _diff_context(expected, actual, header)
+      act, exp = "_tmp.#{rand()}", "_tmp.#{rand()}"
+      File.open(act, 'w') {|f| f.write(@actual) }
+      File.open(exp, 'w') {|f| f.write(expected) }
+      begin
+        diff = `diff -u #{exp} #{act}`
+      ensure
+        File.unlink(act)
+        File.unlink(exp)
+      end
+      diff.sub!(/^---.*\n\+\+\+.*\n/, header)
+      return diff
+    end
+    private :_diff_context
+
+    #def ==(expected); _wrap { @testcase.assert_equal(expected, @actual) } end
+    def ==(expected)
+      _wrap {
+        if @actual != expected && @actual.is_a?(String) && expected.is_a?(String) && expected =~ /\n/
+          diff = _diff_context(expected, @actual, "--- expected\n+++ actual\n")
+          begin
+            @testcase.assert_equal(expected, @actual)
+          rescue Exception => ex
+            ex.message << "\n" << diff.chomp
+            raise ex
+          end
+        else
+          @testcase.assert_equal(expected, @actual)
+        end
+      }
+    end
+    def < (expected); _wrap { @testcase.assert_operator(@actual, :<,  expected) } end
+    def <=(expected); _wrap { @testcase.assert_operator(@actual, :<=, expected) } end
+    def > (expected); _wrap { @testcase.assert_operator(@actual, :>,  expected) } end
+    def >=(expected); _wrap { @testcase.assert_operator(@actual, :>=, expected) } end
+    def =~(expected); _wrap { @testcase.assert_match(expected, @actual) } end
+
+    eval <<-END, binding, __FILE__, __LINE__+1 if RUBY_VERSION >= "1.9"
+    def !=(expected); _wrap { @testcase.assert_not_equal(expected, @actual) } end
+    def !~(expected); _wrap { @testcase.assert_no_match(expected, @actual) } end
+    END
+
+    def nil?        ();         _wrap { @testcase.assert_nil(@actual) } end
+    def same?       (expected); _wrap { @testcase.assert_same(expected, @actual) } end
+    #def is_a?      (expected); _wrap { @testcase.assert_kind_of(expected, @actual) } end
+    def kind_of?    (expected); _wrap { @testcase.assert_kind_of(expected, @actual) } end
+    def instance_of?(expected); _wrap { @testcase.assert_instance_of(expected, @actual) } end
+    def in_delta?   (expected, delta); _wrap { @testcase.assert_in_delta(expected, @actual, delta) } end
+    def respond_to? (expected); _wrap { @testcase.assert_respond_to(@actual, expected) } end
+
+    def raise?(errcls, errmsg=nil)
+      #if block_given?
+      #  ex = @testcase.assert_raise(errcls) { yield }
+      #  @testcase.assert_equal(errmsg, ex.message) if errmsg
+      #else
+      _wrap {
+        proc_obj = @block || @actual
+        ex = @testcase.assert_raise(errcls) { proc_obj.call }
+        if errmsg
+          errmsg.is_a?(Regexp) ? @testcase.assert_match(errmsg, ex.message) \
+                               : @testcase.assert_equal(errmsg, ex.message)
+        end
+        class << proc_obj
+          def exception; @_exception; end
+        end
+        proc_obj.instance_variable_set(:@_exception, ex)
+        ex
+      }
+      #end
+    end
+
+    def throw?(expected)
+      _wrap {
+        proc_obj = @block || @actual
+        @testcase.assert_throws(expected) { proc_obj.call }
+      }
+    end
+
+    def file_exist?
+      _wrap {
+        File.file?(@actual) or
+          @testcase.flunk "File '#{@actual}' not exist."
+      }
+    end
+
+    def dir_exist?
+      _wrap {
+        File.directory?(@actual) or
+          @testcase.flunk "Directory '#{@actual}' not exist."
+      }
+    end
+
+    def exist?
+      _wrap {
+        raise NoMethodError.new("'exist?()' is available only with '.NOT'. please use 'file_exist?' or 'dir_exist?' instead.")
+      }
+    end
+
+    def called?(expected)
+      _wrap {
+        defined?(Section9::Recorder)  or
+          raise ArgumentError.new("Recorder class is not defined: please require 'section9/recorder'.")
+        @actual.is_a?(Section9::Recorder::Called)  or
+          raise ArgumentError.new("called?(): actual should be Recorder::Called object, but #{expected.inspect}.")
+        c = @actual
+        case expected
+        when Array
+          arr = expected
+          arr[0] == c.obj   or @testcase.assert_equal arr[0], c.obj,  "receiver object: "
+          arr[1] == c.name  or @testcase.assert_equal arr[1], c.name, "method name: "
+          arr[2] == c.args  or @testcase.assert_equal arr[2], c.args, "arguments: "
+          arr[3] == c.ret   or @testcase.assert_equal arr[3], c.ret,  "return value: "
+          @testcase.assert_equal arr, c.to_a
+        when Hash
+          d = expected.dup()
+          [:obj, :name, :args, :ret].each {|key| d.delete(key) }
+          d.each {|k, v| raise ArgumentError.new("#{k.inspect}: unexpected key for verify.called?().") }
+          d = expected
+          ! d.key?(:obj)  || d[:obj]  == c.obj   or @testcase.assert_equal d[:obj],  c.obj,  "receiver object: "
+          ! d.key?(:name) || d[:name] == c.name  or @testcase.assert_equal d[:name], c.name, "method name: "
+          ! d.key?(:args) || d[:args] == c.args  or @testcase.assert_equal d[:args], c.args, "arguments: "
+          ! d.key?(:ret)  || d[:ret]  == c.ret   or @testcase.assert_equal d[:ret],  c.ret,  "return value: "
+        else
+          msg = "verify.called?(): argument should be Array or Hash, but got #{d.inspect}."
+          raise ArgumentError.new(msg)
+        end
+      }
+    end
+
+    def method_missing(method_name, *args)
+      _wrap {
+        _method_missing(true, method_name, *args)
+      }
+    end
+
+  end
+
+
+  class VerifyNotObject < VerifyBaseObject
+
+    def initialize(testcase, actual=nil, location=nil, &block)
+      @testcase = testcase
+      @actual = actual
+      @block = block
+      @location = location
+    end
+    attr_accessor :location
+
+    def < (expected); _wrap { @testcase.assert_operator(@actual, :>=, expected) } end
+    def <=(expected); _wrap { @testcase.assert_operator(@actual, :>,  expected) } end
+    def > (expected); _wrap { @testcase.assert_operator(@actual, :<=, expected) } end
+    def >=(expected); _wrap { @testcase.assert_operator(@actual, :<,  expected) } end
+
+    def ==(expected); _wrap { @testcase.assert_not_equal(expected, @actual) } end
+    def =~(expected); _wrap { @testcase.assert_no_match(expected, @actual) } end
+
+    eval <<-END, binding, __FILE__, __LINE__+1 if RUBY_VERSION >= "1.9"
+    def !=(expected); _wrap { @testcase.assert_equal(expected, @actual) } end
+    def !~(expected); _wrap { @testcase.assert_match(expected, @actual) } end
+    END
+
+    def nil?        ()        ; _wrap { @testcase.assert_not_nil(@actual) } end
+    def same?       (expected); _wrap { @testcase.assert_not_same(expected, @actual) } end
+    #def is_a?      (expected); _wrap { @testcase.assert_not_kind_of(expected, @actual) } end
+    def kind_of?    (expected); _wrap { @testcase.assert_not_kind_of(expected, @actual) } end
+    def instance_of?(expected); _wrap { @testcase.assert_not_instance_of(expected, @actual) } end
+    def in_delta?   (expected, delta); _wrap { @testcase.assert_not_in_delta(expected, @actual, delta) } end
+    def respond_to? (expected); _wrap { @testcase.assert_not_respond_to(@actual, expected) } end
+
+    def raise?
+      _wrap {
+        #if block_given?
+        #  @testcase.assert_nothing_raised { yield }
+        #else
+          proc_obj = @block || @actual
+          @testcase.assert_nothing_raised { proc_obj.call }
+        #end
+      }
+    end
+
+    def throw?
+      _wrap {
+        proc_obj = @block || @actual
+        @testcase.assert_nothing_thrown { proc_obj.call }
+      }
+    end
+
+    def file_exist?
+      _wrap {
+        raise NoMethodError.new("'file_exist?()' is not available with '.NOT'. please use '.NOT.exist?' instead.")
+      }
+    end
+
+    def dir_exist?
+      _wrap {
+        raise NoMethodError.new("'dir_exist?()' is not available with '.NOT'. please use '.NOT.exist?' instead.")
+      }
+    end
+
+    def exist?
+      _wrap {
+        ! File.exist?(@actual)  or
+          @testcase.flunk "#{File.directory?(@actual) ? 'Directory' : 'File'} '#{@actual}' exists unexpectedly."
+      }
+    end
+
+    def called?(arg)
+      _wrap {
+        raise NoMethodError.new("'called?()' is not available with '.NOT'.")
+      }
+    end
+
+    def method_missing(method_name, *args)
+      _wrap {
+        _method_missing(false, method_name, *args)
+      }
+    end
+
+  end
+
+
+  ##
+  ## testcase helper
+  ##
+  module TestCaseHelper
+
+    def teardown
+      super
+      @_tmp.revert if @_tmp
+      @_at_end_callbacks.each {|block| block.call }.clear if @_at_end_callbacks
+    end
+
+    def tmp
+      return @_tmp ||= Section9::Tmp.new
+    end
+
+    def at_end(&block)
+      (@_at_end_callbacks ||= []) << block
+    end
+
+    def recorder
+      require 'section9/recorder' unless defined?(Section9::Recorder)
+      return Section9::Recorder.new
+    end
+
+  end
+  TestCase.class_eval { include TestCaseHelper }
+
+
+end
+
+
+TC = Section9::UnitTest::TestCase
+
+
+## Fix a bug on MiniTest
+if defined?(MiniTest)
+
+    Test::Unit::Assertions.class_eval do
+      def build_message(head, template=nil, *arguments) #:nodoc:
+        template &&= template.chomp
+        #template.gsub(/\?/) { mu_pp(arguments.shift) }
+        template.gsub(/(\\)?\?/) { $1 ? '?' : mu_pp(arguments.shift) }
+      end
+    end
+
+end