minitest-filecontent 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2c6d3ba73fb0b3d7f25ea36866fe71a2b552aeb
+  data.tar.gz: eb92bfdeac003881f7cfd6627c5d5e22799e589b
+SHA512:
+  metadata.gz: 028988b9d09eaff1b71c590d685511b02f6fb3720a21766354b1a96b5febf0d3626c2f9e054015ec97cc658071812420c109fdc7dd42f02b257d036bf8c733d3
+  data.tar.gz: 293534e549eccf6a8f7bb9658c1bef4b38365b3de5136d03b4aa4e7ef05b0ea99866aba1be2f11150d2a42f6a97b39f385f6d43ad4120a394c01f20ffa50447d

data/examples/example_minitest_filecontent.rb

@@ -0,0 +1,37 @@
+#encoding: utf-8
+=begin rdoc
+Example for usage of gem minitest-filecontent
+=end
+$:.unshift('../lib')
+require 'minitest/filecontent'
+
+#Some content to be tested.
+DUMMYTEXT = <<dummytext
+Some text to be tested.
+More text.
+dummytext
+
+puts "===================="
+puts "=Remark: This example works correct, if 2 of the 3 assertions fail"
+puts "=After the execution, there should be a directory failure_<isodate> with real results"
+puts "===================="
+
+class TestExample < MiniTest::Test
+  def test_missing_reference_file
+    assert_equal_filecontent('not_existing_filename.txt', DUMMYTEXT, 'My test with a missing reference file works correct, if this error is reported')
+  end
+  def test_file
+    filename = '%s.txt' % __method__
+    File.open(filename, 'w'){|f| f << DUMMYTEXT }
+    assert_equal_filecontent(filename, DUMMYTEXT)
+  end
+  def test_file_difference
+    filename = '%s.txt' % __method__
+    File.open(filename, 'w'){|f| 
+      f << DUMMYTEXT
+      f << "and some other text"
+    }
+    assert_equal_filecontent(filename, DUMMYTEXT, 'My test with a modified content works correct, if this error is reported')
+  end
+end
+

data/lib/minitest/filecontent.rb

@@ -0,0 +1,173 @@
+#encoding: utf-8
+=begin rdoc
+=Gem MiniTest-Filecontent
+
+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: MiniTest::Test#assert_equal_filecontent
+
+=end
+
+gem 'minitest', '>= 4.0.0'
+require 'minitest/autorun'
+
+require 'fileutils'
+require 'date'  #needed for Ruby 1.9 (class Date no standard?)
+
+
+#
+module MiniTest
+  module Filecontent
+    VERSION = '0.1.0'
+  end
+  
+=begin rdoc
+Extend the class TestCase with additional methods/assertions:
+
+* MiniTest::Test#assert_equal_filecontent
+=end  
+  class Test
+    #Default path in case of an error.
+    FOLDER_FOR_FAILURE = "failure_#{Date.today}"
+    #Default path in case of an error. Overwrites FOLDER_FOR_FAILURE.
+    #With 'false' no file is written
+    attr_writer :folder_for_failure
+=begin rdoc
+Takes the content of the file 'filename' and compares it with 'actual' like in assert_equal.
+If 'filename' 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), 
+                              'short description of test'
+                            )
+
+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 (See FOLDER_FOR_FAILURE )
+5. The file 'test_section.html' with the result is created in FOLDER_FOR_FAILURE
+6. You can use a compare tool to compare the expected result and the real result.
+
+If you don't want a failure file (step 4 and 5), you may suppress it with:
+  def text_no_failure file
+    self.folder_for_failure = false  #inactivate error/reference file creation.
+    #...
+  end
+
+==Recommendation to build up your test.
+1. Define your tests with your assertions.
+2. Run the test 
+3. You will get errors 'Reference file <xx/not_available.txt> missing'
+  and a directory 'failure_<date>
+4. Rename the folder 'failure' to 'expected'
+5. Check, if the content of the folder is the wanted result.
+6. Rerun again, you have no failure (hopefully ;-) )
+
+If you already have the result, you may start like this:
+1. Create a folder: 'expected'
+2. Define your assertion with non-existing filename in the 'expected'-folder.
+3. Copy the expected results to the 'expected'-folder.
+4. Run the test
+5. In case of errors:
+Compare the content of the 'expected'-folder with the failure-folder.
+Adapt your code or your expected result.
+6. Rerun again, until you get the expected results
+
+==filename
+The filename may contains some parameters in <x>. 
+Details see MiniTest::Test#build_filename      
+
+=end
+    def assert_equal_filecontent( filename, actual, message = nil )
+      
+      filename = build_filename(filename)
+      #Set encoding for the file
+      encoding = actual.encoding if actual.respond_to?(:encoding)
+      encoding ||= 'Binary' 
+      
+      full_message = []
+      full_message << message if message
+      
+      expected = nil
+      if File.exist?(filename)
+        File.open(filename, 'r', :external_encoding => encoding ){|file| expected = file.read }
+        #This message is only used in case of a difference
+        full_message << "Result differs to file content #{filename}" 
+      else
+        full_message << "Reference file <#{filename}> is missing"
+      end
+      
+      #Write the real result to a file if a failure folder is given.
+      if @folder_for_failure != false and expected  != actual
+        folder_for_failure = @folder_for_failure || FOLDER_FOR_FAILURE 
+        FileUtils.makedirs(folder_for_failure) unless File.directory?(folder_for_failure)
+        File.open( "#{folder_for_failure}/#{File.basename(filename)}", 'w', :external_encoding => encoding){|f|
+          f << actual
+        }
+        full_message << "\t-> Build <#{folder_for_failure}/#{File.basename(filename)}>"
+      end
+      
+
+      assert( expected == actual, full_message.join("\n") )
+
+    end #assert_equal_filecontent( filename, actual, message = nil )
+
+=begin rdoc
+Make filename conversion.
+
+The filename may contains some parameters in <x>. _x_ may be:
+* c - test class name
+* m - methodname from caller[level]
+* cm - test class name - methodname
+
+Parameter 'level' is needed to get the method.
+
+Example:
+
+  class MyTest < Test::Unit::TestCase
+    def test_xx
+      assert_equal_filecontent( "<m>.txt", mycode )
+    end
+  end 
+
+The caller stack will be
+  ___lib/more_unit_test/assert_equal_filecontent.rb:112:in `assert_equal_filecontent'
+  quicktest.rb:13:in `test_xx'
+  ___test-unit-2.4.0/lib/test/unit/testcase.rb:531:in `run_test'
+
+The result with default level 1 is 'test_xx' - the method from your test.
+
+=end
+    def  build_filename(filename, level = 1)
+      method = caller[level].match(/^(.+?):(\d+)(?::in `(.*)')?/)[3]  #methodname
+      filename.gsub(/<.*?>/){ |hit|
+        case hit
+          when '<c>'; self.class.name
+          when '<m>'; method
+          when '<cm>'; "#{self.class}-#{method}" #methodname
+          else; raise ArgumentError, "Undefined option #{hit} in filename #{filename}"
+        end
+      }.sub(/block (\(\d+ levels\) )?in /,'')
+    end  #
+  end  #class Test
+end #Minitest
+
+__END__
+

data/readme.rdoc

@@ -0,0 +1,24 @@
+=MiniTest-Filecontent
+
+Compare expected result with content of a file.
+
+Usefull, if you compare long strings or generated texts in your tests.
+
+See MiniTest::Test for details.
+
+
+=Related Gems
+
+==Minitest
+MiniTest-Filecontent is a extension of Minitest
+
+* https://rubygems.org/gems/minitest
+
+
+
+==Minitest::Filesystem
+Check content of a filesystem.
+This gem checks the existence of files and directory structures.
+There is no check and comparison of the content of files.
+
+* https://rubygems.org/gems/minitest-filesystem

data/unittest/test_minitest_filecontent.rb

@@ -0,0 +1,182 @@
+#encoding: utf-8
+=begin rdoc
+Tests for minitest-filecontent
+=end
+$:.unshift('../lib')
+require 'minitest/filecontent'
+
+#Some content to be tested.
+DUMMYTEXT = <<dummytext
+Some text to be tested.
+More text.
+dummytext
+
+DUMMYTEXT_utf = <<dummytext
+Some text to be tested.
+More text.
+
+Umlauts: öäü
+dummytext
+
+#
+#This two directories will be created.
+#
+$expected = File.dirname(__FILE__) + '/tmp_expected'
+$folder_for_failure  = File.dirname(__FILE__) + '/tmp_failure'
+
+
+
+#
+class Test_equal_filecontent_filename < MiniTest::Test
+  def test_normal
+    assert_equal('x', build_filename('x'))
+  end
+  def test_c
+    assert_equal(self.class.to_s, build_filename('<c>'))
+  end
+  def test_m
+    assert_equal(__method__.to_s, build_filename('<m>',0))
+    assert_equal('test_m', build_filename('<m>',0))
+  end
+  def test_cm
+    assert_equal("#{self.class}-#{__method__}", build_filename('<cm>',0))
+  end
+
+  #test if the filename is taken from deeper.
+  def my_cascaded_test(methodname, level=0)
+    assert_equal(methodname.to_s, build_filename('<m>',level), 'The filename is not generated by the calling process')
+  end
+  def my_cascaded_test2(methodname, level)
+    my_cascaded_test(methodname, level)
+  end
+  def test_m_cascaded
+    my_cascaded_test('my_cascaded_test')
+    my_cascaded_test(__method__,1)
+    my_cascaded_test2(__method__,2)
+  end
+end #Test_equal_filecontent_filename
+
+=begin
+This is a test in the test (we test with MiniTest the behavour of minitest.
+
+Example:
+
+    msg = assert_raises( Minitest::Assertion ){
+      assert_equal_filecontent( "#{$expected}/test_build.txt", DUMMYTEXT )
+    }
+    
+assert_raises checks, if the check assert_equal_filecontent throws an test-exception.
+This exception (msg) can be analysed.
+=end
+class Test_equal_filecontent < MiniTest::Test
+  
+  #~ Minitest::Assertion = Test::Unit::Minitest::Assertion
+  
+  #Build reference data
+  def self.before_tests()
+    FileUtils.makedirs($expected)
+    File.open("#{$expected}/test.txt", 'w'){|f| f << DUMMYTEXT }
+    File.open("#{$expected}/test_utf.txt", 'w:utf-8'){|f| f << DUMMYTEXT_utf }
+    File.open("#{$expected}/test_build.txt", 'w'){|f| f << DUMMYTEXT*2 }
+  end
+  before_tests()  #init
+  def self.after_tests
+    ###FIXME does not work
+        
+    FileUtils.rmtree($expected)
+    FileUtils.rmtree($folder_for_failure)
+    FileUtils.rmtree(FOLDER_FOR_FAILURE)
+  end
+  
+  def test_ok()
+    #~ #Make test
+    assert_equal_filecontent( "#{$expected}/test.txt", DUMMYTEXT )
+  end
+  
+  def test_utf()
+    assert_equal_filecontent( "#{$expected}/test_utf.txt", DUMMYTEXT_utf )
+  end
+
+#Check error
+  def test_no_reference_file()
+    self.folder_for_failure = false  #inactivate error/reference file creation.
+    #Check exception and get the message
+    msg = assert_raises( Minitest::Assertion ){
+      assert_equal_filecontent( "#{$expected}/not_available.txt", DUMMYTEXT )
+    }    
+    assert_instance_of(Minitest::Assertion, msg)
+    assert_equal( "Reference file <#{$expected}/not_available.txt> is missing", msg.to_s)
+  end
+  
+  #Check, if "Failure" is created in default path
+  def test_build_reference_file_default_path()
+    
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raises( Minitest::Assertion ){
+      assert_equal_filecontent( "#{$expected}/test_build.txt", DUMMYTEXT )
+    }
+    assert_match( %r{Result differs to file content #{$expected}/test_build.txt\n\t-> Build <#{FOLDER_FOR_FAILURE}/test_build.txt}m, 
+                        msg.to_s, 'Difference message is wrong' )
+    
+    #Check for file with correkt result
+    assert(File.exist?("#{FOLDER_FOR_FAILURE}/test_build.txt"), 'Reference file is not created')
+    #Check with new file (normally you would copy the file to $expected
+    assert_equal_filecontent( "#{FOLDER_FOR_FAILURE}/test_build.txt", DUMMYTEXT, nil )
+  end
+
+  #Check, if "Failure" is created in other path
+  def test_build_reference_file_default_path()
+    self.folder_for_failure = $folder_for_failure #set other failure folder for assertion in this test
+    
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raises( Minitest::Assertion ){
+      assert_equal_filecontent( "#{$expected}/test_build.txt", DUMMYTEXT )
+    }
+    assert_match( %r{Result differs to file content #{$expected}/test_build.txt\n\t-> Build <#{$folder_for_failure}/test_build.txt}m, 
+                        msg.to_s, 'Difference message is wrong' )
+    
+    #Check for file with correkt result
+    assert(File.exist?("#{$folder_for_failure}/test_build.txt"), 'Reference file is not created')
+    #Check with new file (normally you would copy the file to $expected
+    assert_equal_filecontent( "#{$folder_for_failure}/test_build.txt", DUMMYTEXT, nil )
+  end
+
+  def test_build_reference_file_parameter_error()    
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raises( ArgumentError ){
+      assert_equal_filecontent( "<??>.txt", DUMMYTEXT )
+    }
+  end
+  
+  def test_build_reference_file_parameter_c()    
+    filename = self.class.name
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raises( Minitest::Assertion ){
+      assert_equal_filecontent( "#{$expected}/<c>.txt", DUMMYTEXT )
+    }
+    assert_match( %r{Reference file <#{$expected}/#{filename}.txt> is missing.*-> Build <#{FOLDER_FOR_FAILURE}/#{filename}.txt}m, 
+                        msg.to_s )
+
+    #Check for file with correkt result
+    assert(File.exist?("#{FOLDER_FOR_FAILURE}/#{filename}.txt" ))
+    #Check with new file (normally you would copy the file to $expected
+    assert_equal_filecontent( "#{FOLDER_FOR_FAILURE}/#{filename}.txt", DUMMYTEXT, nil )
+  end
+  
+  def test_build_reference_file_parameter_m()
+    filename = __method__
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raises( Minitest::Assertion ){
+      assert_equal_filecontent( "#{$expected}/<m>.txt", DUMMYTEXT )
+    }
+    assert_match( %r{Reference file <#{$expected}/#{filename}.txt> is missing.*-> Build <#{FOLDER_FOR_FAILURE}/#{filename}.txt}m, 
+                        msg.to_s )
+
+
+    #Check for file with correkt result
+    assert(File.exist?("#{FOLDER_FOR_FAILURE}/#{filename}.txt" ))
+    #Check with new file (normally you would copy the file to $expected
+    assert_equal_filecontent( "#{FOLDER_FOR_FAILURE}/#{filename}.txt", DUMMYTEXT, nil )
+  end
+  
+end #Test_equal_filecontent 

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: minitest-filecontent
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Knut Lickert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Support unit tests with expectations in files
+email: knut@lickert.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- readme.rdoc
+files:
+- examples/example_minitest_filecontent.rb
+- lib/minitest/filecontent.rb
+- readme.rdoc
+- unittest/test_minitest_filecontent.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- readme.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Support unit tests with expectations in files
+test_files:
+- unittest/test_minitest_filecontent.rb