more_unit_test 0.0.2

data/lib/assert_equal_filecontent.rb

@@ -0,0 +1,77 @@
+=begin rdoc
+Imagine you have a method and the result is a long text.
+
+You can compare the result via assert_equal, but in case of
+an error you must find the difference in the long text.
+
+Wouldn't it be nice, you can store your expected result in a file and
+in case of differences you get the real result in another file?
+Now you can take your favorite file difference tool and can compare
+the expected and the real result.
+
+Here it is: Test::Unit::TestCase#assert_equal_filecontent
+
+See http://rubyforge.org/tracker/?func=detail&aid=19509&group_id=5650&atid=21859
+=end
+require 'test/unit'
+require 'ftools'
+#
+#Extend the class TestCase with additional methods/assertions
+#
+class Test::Unit::TestCase
+  #
+  #Takes the content of the file 'filename' and compares it with 'actual' like in assert_equal.
+  #If 'filname' doesn't exist, the failure 
+  # Reference file <#{filename}> missing
+  #is returned.
+  #
+  #'folder_for_failure' will contain all results with differences.
+  #
+  #Example of the usage:
+  #    assert_equal_filecontent( "expected/test_section.html", text.to_doc(:html))
+  #
+  #What will happen:
+  #1. text.to_doc(:html) is the test. It creates some HTML-Text
+  #2. "expected/test_section.html" is read and compared to text.to_doc(:html)
+  #   1. If the file is missing -> error
+  #   2. If it is the same -> fine 
+  #   3. If there are differences:
+  #3. A message is given (like in assert_equal)
+  #4. A folder "failure#{Date.today}" is created if not already exist
+  #5. The file 'test_section.html' with the result is created in "failure#{Date.today}/"
+  #6. I can use a compare tool to compare the expected result and the real result.
+  #
+  #Recommendation to build up your test.
+  #1. Create two folders: 'expected' and 'failure'
+  #2. Define your assertion with a non-existing filename
+  #3. Run the test with folder_for_failure = 'failure'
+  #4. You will get a failure (filename is missing).
+  #5. Copy the file in 'failure' to 'expected'
+  #6. Rerun again, you have no failure (hopefully ;-) )
+  def assert_equal_filecontent( filename, actual, folder_for_failure = "failure#{Date.today}", message = nil )
+    #
+    #Make the tests
+    if File.exist?(filename)
+      expected = File.read(filename) 
+      full_message = build_message(message, "<?> expected (#{filename}) but was\n<?>.\n", expected, actual).to_s
+    else
+      full_message = "Reference file <#{filename}> missing"
+    end
+
+    #Write the real result to a file if a failure folder is given.
+    if folder_for_failure and expected  != actual
+      File.makedirs(folder_for_failure) if ! File.directory?(folder_for_failure)
+      File.open( "#{folder_for_failure}/#{File.basename(filename)}", 'w'){|f|
+        f << actual
+      }
+      full_message << "\n\t-> Build <#{folder_for_failure}/#{File.basename(filename)}>"
+    end
+
+    if File.exist?(filename)
+      assert_block( full_message ){ expected  == actual }
+    else
+      assert_block( full_message ){ false }
+    end
+  end
+  #
+end

data/lib/assert_stdout.rb

@@ -0,0 +1,186 @@
+#
+#Add some funcionality to check stdout and stderr-output with test/unit.
+#
+#Example:
+#  require 'assert_stdout'
+#  class MyTest < Test::Unit::TestCase  
+#    #This is a method and I wnat to test the screen output.
+#    def any_output()
+#      puts "Just some output"
+#    end
+#    def test_stdout_ok()
+#      assert_stdout("Just some output\n", proc{ any_output()} )
+#      assert_stdout_block("Just some output\n"){ any_output() }
+#    end
+#  end
+#
+#Please be aware:
+#Normally you should not test the output of methods, but the result of methods.
+#
+require 'test/unit'
+module Test::Unit
+
+#Class to catch the std output and stderr
+class Catch_IO	< String
+  #Receive content
+	def write( cont )
+		self	<< cont
+	end
+end	#MyIO
+
+#
+#Extend the class TestCase with additional methods/assertions
+#
+class TestCase
+  #Catch stdout for a given procedure (Proc-Element).
+  def catch_stdout( procedure )
+    $stdout = output = Catch_IO.new #temporary copy
+    procedure.call
+    $stdout = STDOUT
+    output
+  end
+=begin rdoc  
+  Compare the stdout-output with your exception.
+  
+  Actual must be a procedure.
+  Another object (like a method call) would be executed first, before stdout could be redirected.
+  
+  Example:
+      require 'assert_stdout'
+      class MyTest < Test::Unit::TestCase  
+        def test_hello_world()
+          assert_stdout("Hello World\n", Proc.new{ puts 'Hello World'} )
+        end
+      end
+=end
+  def assert_stdout( expected, actual, message = nil )
+    if actual.respond_to?(:call)
+      output = catch_stdout( actual )
+      full_message = build_message(message, "<?> expected in stdout, but was\n<?>.\n", expected, output)
+      assert_block( full_message ){ expected  == output }
+    else
+      raise 'no Proc-object given'
+      full_message = build_message(message, "<?> expected in stdout, but no Proc-object is given to test.\n", expected )
+      assert_block( full_message ){ false } #force error
+    end
+  end
+=begin rdoc  
+Compare the stdout-output of a given block with your exception.
+
+Example:
+  require 'assert_stdout'
+  class MyTest < Test::Unit::TestCase  
+    def test_hello_world()
+      assert_stdout_block("Hello World\n"){ puts 'Hello World'}
+    end
+  end
+=end  
+  def assert_stdout_block( expected, message = nil )
+    if block_given? 
+      $stdout = output = Catch_IO.new #temporary copy
+      yield
+      $stdout = STDOUT
+      full_message = build_message(message, "<?> expected in stdout, but was\n<?>.\n", expected, output)
+      assert_block( full_message ){ expected  == output }
+    else
+      raise 'no block given'
+      full_message = build_message(message, "<?> expected in stdout, but no block to test.\n", expected )
+      assert_block( full_message ){ false }
+    end
+  end
+=begin rdoc  
+Catch stderr for a given procedure (Proc-Element).
+=end
+  def catch_stderr( procedure )
+    $stderr = output = Catch_IO.new #temporary copy
+    procedure.call
+    $stderr = STDERR
+    output
+  end
+=begin rdoc
+Compare the stderr-output with your exception.
+
+Actual must be a procedure.
+Another object (like a method call) would be executed first, before stderr could be redirected.
+
+Example:
+  require 'assert_stdout'
+  def puts_err( arg )
+    $stderr << arg
+  end
+
+  class MyTest < Test::Unit::TestCase  
+    def test_hello_world()
+      assert_stderr("Hello World", Proc.new{ puts_err 'Hello World'} )
+    end
+  end
+=end
+  def assert_stderr( expected, actual, message = nil )
+    if actual.respond_to?(:call)
+      output = catch_stderr( actual )
+      full_message = build_message(message, "<?> expected in stderr, but was\n<?>.\n", expected, output)
+      assert_block( full_message ){ expected  == output }
+    else
+      raise 'no Proc-object given'
+      full_message = build_message(message, "<?> expected in stderr, but no Proc-object is given to test.\n", expected )
+      assert_block( full_message ){ false } #force error
+    end
+  end
+=begin rdoc
+Compare the stderr-output with your exception.
+
+Example:
+  require 'assert_stdout'
+  def puts_err( arg )
+    $stderr << arg
+  end
+
+  class MyTest < Test::Unit::TestCase  
+    def test_hello_world()
+      assert_stderr_block("Hello World"){ puts_err 'Hello World'}
+    end
+  end
+=end
+  def assert_stderr_block( expected, message = nil )
+    if block_given? 
+      $stderr = output = Catch_IO.new #temporary copy
+      yield
+      $stderr = STDERR
+      full_message = build_message(message, "<?> expected in stderr, but was\n<?>.\n", expected, output)
+      assert_block( full_message ){ expected  == output }
+    else
+      raise 'no block given'
+      full_message = build_message(message, "<?> expected in stderr, but no block to test.\n", expected )
+      assert_block( full_message ){ false }
+    end
+  end
+end   #class TestCase
+end   #module Test::Unit
+
+__END__
+
+class MyIO	< String
+	def write( cont )
+		self	<< cont
+	end
+  def self.catch_stdout( procedure )
+    $stdout = output = MyIO.new #temporary copy
+    procedure.call
+    $stdout = STDOUT
+    output
+  end
+end	#MyIO
+
+#How to get stdout
+puts 'vorher'
+$stdout = output = MyIO.new #temporary copy
+puts 'YY'
+$stdout = STDOUT
+puts 'nachher'
+puts output
+
+
+puts 'vorher'
+output = MyIO.catch_stdout( proc{ puts 'xxYY' } )
+puts 'nachher'
+puts output

data/lib/catch_output.rb

@@ -0,0 +1,105 @@
+#
+#Catch screen output.
+#Can be used to avoid messages from programms called by system
+#
+#Example:
+#    require 'catch_output'
+#    include Catch_output
+#    stdout, stderr = catch_screen_output{ 
+#      %x{my_shell_application}
+#    }
+#
+
+
+
+#Class Tempfile for temporary redirection of stdout and stderr
+require "tempfile" 
+
+#Catch screen output.
+#Can be used to avoid messages from programms called by system
+module Catch_output
+  STDOUT_ORIG	= STDOUT.clone()
+  STDERR_ORIG	= STDERR.clone()
+
+  #Catch stdout for the given block, but print stderr.
+  def catch_stdout( &block )
+    #~ raise 'no block' unless block_given? 
+    raise 'no block' unless block.is_a?(Proc)
+    stdout, stderr = catch_screen_output( true, false, &block )
+    return stdout
+  end #catch_stdout()
+
+  #Catch stderr for the given block, but print stdout.
+  def catch_stderr( &block )
+    #~ raise 'no block' unless block_given? 
+    raise 'no block' unless block.is_a?(Proc)
+    stdout, stderr = catch_screen_output( false, true, &block )
+    return stderr
+  end #catch_stderr()
+  
+  #Catch the screen output (stdout and stderr) for the given block.
+  #You can set, which output you want to catch.
+  #
+  #Returnvalue is an array with the result of stdout and stderr.
+  #If any output wasn't catched, the return value in the array is nil.
+  def catch_screen_output(
+      catch_stdout = true,
+      catch_stderr = true,
+      stdout_orig	= STDOUT.clone(),
+      stderr_orig	= STDERR.clone()
+      )
+      
+    raise 'no block' unless block_given? 
+       
+    if catch_stdout
+      #Create temporary file for stdout
+      tmpstdout = Tempfile.new( 'stdout')
+      #redirect stdout
+      STDOUT.reopen( tmpstdout ) 
+    end
+    if catch_stderr
+      #Create temporary file for stdout
+      tmpstderr = Tempfile.new( 'stderr')
+      #redirect stdout
+      STDERR.reopen( tmpstderr ) 
+    end
+    
+
+    yield #Execute the block
+    
+    if catch_stdout
+      #stdout is coming again to the screen.
+      tmpstdout.close()    
+      STDOUT.reopen( stdout_orig)
+      
+      # Get the result of stdout
+      tmpstdout.open()
+      stdout = tmpstdout.readlines().join
+      tmpstdout.close()
+    end
+    
+
+    if catch_stderr
+      #stderr is coming again to the screen.
+      tmpstderr.close()    
+      STDERR.reopen( stderr_orig)
+      
+      # Get the result of stderr
+      tmpstderr.open()
+      stderr = tmpstderr.readlines().join
+      tmpstderr.close()
+    end
+    return [ stdout, stderr ]
+  end
+end
+
+
+#Frame to use module Catch_output
+#
+#Example:
+#   Frame_catch_output.catch_stdout{ puts 11 }
+class Frame_catch_output
+  class << self 
+  include Catch_output
+  end
+end

data/readme.html

@@ -0,0 +1,40 @@
+<!--
+
+	Build by	C:/Program Files/ruby/lib/ruby/gems/1.8/gems/docgenerator-1.2.0/./lib/docgenerator/document.rb
+	Dir:		C:/usr/Script/more_unit_test
+	Creator:	rakefile.rb
+	Target:		readme.html
+	2010/01/02 01:00:41
+	
+	Generation-Info-End
+-->
+<!doctype html public "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head ></head>
+<body ><p >
+The more_unit_test-package extends test/unit with some additional tests:  
+</p>
+<ul >
+<li > assert_equal_filecontent.rb: Compare expected result with file content  </li>
+<li > assert_stdout.rb: test for stdout/stderr Test cases are added to the files directly.  </li>
+</ul>
+<p >
+In addition you get a function to catch outputs on stdout and stderr:  
+</p>
+<ul >
+<li > catch_output.rb  </li>
+</ul>
+<h1 >Version history:</h1>
+<p >
+0.0.1: Initial version.  
+</p>
+<p >
+0.0.2:  
+</p>
+<ul >
+<li > modified folder structure  </li>
+<li > more documentation.  </li>
+<li > published at gemcutter  </li>
+</ul>
+</body>
+</html>

data/readme.txt

@@ -0,0 +1,19 @@
+
+
+The more_unit_test-package extends test/unit with some additional tests:  
+-  assert_equal_filecontent.rb: Compare expected result with file content  
+-  assert_stdout.rb: test for stdout/stderr Test cases are added to the files directly.  
+
+In addition you get a function to catch outputs on stdout and stderr:  
+-  catch_output.rb  
+
+Version history:
+    ------------------------------
+
+0.0.1: Initial version.  
+
+0.0.2:  
+-  modified folder structure  
+-  more documentation.  
+-  published at gemcutter  
+

data/unittest/test_assert_equal_filecontent.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require "../lib/assert_equal_filecontent.rb"
+
+#Some content to be tested.
+DUMMYTEXT = <<dummytext
+Some text to be tested.
+More text.
+dummytext
+
+#
+#This is a test in the test -> we need test_assertions.rb, not only test/unit
+#test_assertions.rb is not in path of tests -> full path, please adapt for your installation.
+require "C:/Program Files/ruby/doc/ruby/ruby-1.8.6/test/testunit/test_assertions.rb"
+#~ require 'test/testunit/test_assertions'
+
+#
+class MyTest < Test::Unit::TC_Assertions
+  def test_ok()
+    #Build reference data
+    File.makedirs('expected')
+    File.open('expected/test.txt', 'w'){|f| f << DUMMYTEXT }
+    #Make test
+    assert_equal_filecontent( 'expected/test.txt', DUMMYTEXT )
+  end    
+  def test_no_reference_file()
+    check_fails(%r{Reference file <expected/not_available.txt> missing}){
+      assert_equal_filecontent( 'expected/not_available.txt', DUMMYTEXT, nil )
+    }
+  end
+  def test_build_reference_file()
+    #Initial expected file
+    File.makedirs('expected')
+    File.open('expected/test_build.txt', 'w'){|f| f << DUMMYTEXT*2 }
+    #
+    folder_for_failure  = 'failure'
+    #~ assert_equal(false, File.exist?("#{folder_for_failure}/test.txt" ))
+    
+    #First check. There is a difference, in failure we get the correct result
+    check_fails(%r{.*expected \(expected/test_build.txt\) but was.*-> Build <failure/test_build.txt}m){
+      assert_equal_filecontent( 'expected/test_build.txt', DUMMYTEXT, folder_for_failure )
+    }
+    #Check for file with correkt result
+    assert_equal(true, File.exist?("#{folder_for_failure}/test_build.txt" ))
+    #Check with new file (normally you would copy the file to 'expected'
+    assert_equal_filecontent( "#{folder_for_failure}/test_build.txt", DUMMYTEXT, nil )
+  end
+end #class MyTest

data/unittest/test_assert_stdout.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require '../lib/assert_stdout.rb'
+
+
+class MyTest < Test::Unit::TestCase  
+  def any_output()
+    puts "Just some output"
+  end
+  def test_stdout_ok()
+    assert_stdout("xx\n", proc{ puts 'xx' } )
+    assert_stdout("Just some output\n", proc{ any_output()} )
+    assert_stdout_block("xx\n"){ puts 'xx' }
+    assert_stdout_block("Just some output\n"){ any_output() }
+    assert_equal("xx\n", catch_stdout(proc{ puts 'xx' }) )
+  end
+  def test_stdout_err()
+    #Error: No Proc-object
+    assert_raise(RuntimeError){ assert_stdout("xx\n", 1+1) }
+    #Error: No Block
+    assert_raise(RuntimeError){ assert_stdout_block("xx\n") }
+  end
+  #Helper method to get content to stderr.
+  def any_output2stderr()
+    $stderr << "Just some output on stderr"
+  end
+  def test_stderr_ok()
+    #~ assert_stderr("xx\n", proc{ puts 'xx' } )
+    assert_stderr("Just some output on stderr", proc{ any_output2stderr()} )
+    #~ assert_stderr_block("xx\n"){ puts 'xx' }
+    assert_stderr_block("Just some output on stderr"){ any_output2stderr() }
+    #~ assert_equal("xx\n", catch_stderr(proc{ puts 'xx' }) )
+    assert_equal("Just some output on stderr", catch_stderr(proc{ any_output2stderr() } ) )
+  end
+  def test_stderr_err()
+    #Error: No Proc-object
+    assert_raise(RuntimeError){ assert_stderr("xx\n", 1+1) }
+    #Error: No Block
+    assert_raise(RuntimeError){ assert_stderr_block("xx\n") }
+  end
+end #class MyTest

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: more_unit_test
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Knut Lickert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-02 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: |
+  The more_unit_test-package extends test/unit with some additional tests:
+  - assert_equal_filecontent.rb: Compare expected result with file content
+  - assert_stdout.rb: test for stdout/stderr
+
+email: knut@lickert.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- readme.txt
+- readme.html
+- lib/assert_equal_filecontent.rb
+- lib/assert_stdout.rb
+- lib/catch_output.rb
+has_rdoc: true
+homepage: http://gems.rubypla.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Additional assertions for big text results.
+test_files: 
+- unittest/test_assert_stdout.rb
+- unittest/test_assert_equal_filecontent.rb