knut_tools 0.1.0

data/unittest/test_file_winlink.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+
+$:.unshift('../lib') if $0 == __FILE__
+require "knut_tools/file_winlink.rb"
+require "knut_tools/catch_output"
+
+
+class Test_shortcut < Test::Unit::TestCase
+  def setup()
+    @tmpdir = 'tmp_testdata'
+    @linkname = "#{@tmpdir}/link4test.lnk"
+    Dir.mkdir(@tmpdir) unless File.exist?(@tmpdir)
+  end
+  def teardown
+    File.delete(@linkname) if File.exist?(@linkname)
+    Dir.delete(@tmpdir)
+  end
+  #Check behaviour with unexisting files.
+  def test_exceptions()
+    assert_raise(Errno::ENOENT){mk_link( 'no_existing', 'xx.lnk')  }
+  end
+  
+  def test_create()
+    
+    #Clear old testcases.
+    File.delete(@linkname) if File.exist?(@linkname)
+    
+    assert_equal(false, File.exist?(@linkname))
+    Frame_catch_output.catch_stdout{
+      mk_link( __FILE__, @linkname, "This is a link to #{__FILE__}")    
+    }
+    assert_equal(true, File.exist?(@linkname))
+    
+  end  
+end

data/unittest/test_gempackager.rb

@@ -0,0 +1,195 @@
+$:.unshift('../lib') if $0 == __FILE__
+require 'test/unit'
+require 'knut_tools/rake/gempackager.rb'
+require 'knut_tools/catch_output'
+
+class Test_Gem_packer < Test::Unit::TestCase  
+  
+  def test_create()
+    gemdef = Gem_packer.new('test', '0.1.0')
+    assert_kind_of(Gem_packer, gemdef)
+    assert_kind_of(Gem::Specification, gemdef.spec)
+    assert_equal('0.1.0', gemdef.spec.version.to_s)
+    assert_equal(gemdef.version, gemdef.spec.version.to_s)
+    
+    assert_raise(ArgumentError){ Gem_packer.new('test', '0.1.0', :xx=>:c)}
+    assert_raise(ArgumentError){ Gem_packer.new('test', '0.1.0', 1 )}
+
+  end
+  
+  def test_create_block()
+    gemdef = Gem_packer.new('test', '0.1.0'){|gemdef, spec|
+      assert_kind_of(Gem_packer, gemdef)
+      assert_kind_of(Gem::Specification, spec)
+    }    
+  end
+  def test_version()
+    gemdef = Gem_packer.new('test_version', '0.1.0')
+    gemdef.versions << '0.1.0'
+    assert_equal('0.1.0', gemdef.spec.version.to_s)
+    assert_equal(gemdef.version, gemdef.spec.version.to_s)
+    
+    app = Rake.application
+    assert_nothing_raised(){ app["test_version:check_version"].invoke }
+    
+    #force a version error
+    gemdef.spec.version = '1.0.0'
+    app["test_version:check_version"].reenable
+    assert_raise(Gem_packer::VersionError){ app["test_version:check_version"].invoke }
+    
+    #
+    gemdef = Gem_packer.new('test_version2', '0.1.0')
+    gemdef.versions << '0.1.1'  #Assignment must be done before task is called
+    assert_equal('0.1.0', gemdef.spec.version.to_s)
+    assert_equal(gemdef.version, gemdef.spec.version.to_s)
+    assert_raise(Gem_packer::VersionError){ app["test_version2:check_version"].invoke }
+    
+    #~ puts `call rake -f my_rake4gem.rb -T`
+  end
+
+  def test_tasks_generell()
+    app = Rake.application
+    assert_kind_of(Rake::Task, app['default'])
+    assert_kind_of(Rake::Task, app['check_version'])    
+    
+    assert_kind_of(Array, app['check_version'].prerequisites)
+    
+  end
+  def test_tasks()
+    
+    app = Rake.application
+    test_name = 'test_tasks' #test gem for this test. Must be uniq for all tests
+    tasks_before = app.tasks  #get previous task list
+
+    #No test_tasks exist in advance
+    assert_raise(RuntimeError){app[test_name]}
+    Gem_packer::TASKLIST.each{|task|
+      assert_raise(RuntimeError){app["#{test_name}:#{task}"]}
+    }
+
+    #Build new action -> new tasks
+    gemdef = Gem_packer.new(test_name, '0.1.0')
+    
+    #test_tasks exist after gem-definition
+    assert_nothing_raised(RuntimeError){app[test_name]}
+    assert_kind_of(Rake::Task, app[test_name])
+    Gem_packer::TASKLIST.each{|task|
+      assert_nothing_raised('Expected task from Gem_packer::TASKLIST missing'){ app["#{test_name}:#{task}"] }
+      assert_kind_of(Rake::Task, app["#{test_name}:#{task}"])
+      #check 'global' tasks
+      assert_equal(true, app[task].prerequisites.include?("#{test_name}:#{task}"))
+    }
+    
+    #Check special tasks
+    assert_equal(true, app[test_name].prerequisites.include?("#{test_name}:default"))    
+    assert_equal(["check"], app["#{test_name}:default"].prerequisites)
+    assert_equal(%w{check_version check_gemspec}, app["#{test_name}:check"].prerequisites)
+    
+    #All new tasks
+    #~ assert_equal(Gem_packer::TASKLIST.size + 1, (app.tasks - tasks_before).size)
+    assert_equal([test_name] + Gem_packer::TASKLIST.map{|task| "#{test_name}:#{task}"}.sort, 
+                      (app.tasks - tasks_before).map{|x|x.name}
+                  )
+ 
+  end
+=begin rdoc
+This test requires following files to be successfull:
+  testdata/
+  testdata/dummy_test.rb
+=end
+  def test_test_task()
+    
+    app = Rake.application
+    test_name = 'test_test_tasks' #test gem for this test. Must be uniq for all tests
+    gemdef = Gem_packer.new(test_name, '0.1.0')
+    
+    #Missing test directory
+    assert_raise(ArgumentError){ gemdef.define_test()}
+    assert_raise(ArgumentError){ gemdef.define_test('not_existing_directory')}
+    
+    assert_equal(true, File.exist?('testdata'))
+    #Require path missing
+    assert_raise(ArgumentError){ gemdef.define_test('testdata') }
+    
+    #define gem with reachable require path
+    gemdef.spec.require_path = '.'
+    #no test files found
+    assert_raise(ArgumentError){ gemdef.define_test('testdata') }
+    assert_raise(ArgumentError){ gemdef.define_test('testdata', FileList['xxxx']) }
+    
+    #Test files available
+    tasks_before = app.tasks
+    assert_nothing_raised{ 
+      assert_kind_of(Rake::TestTask, gemdef.define_test('testdata', FileList['dummy_test.rb']))
+    }
+    #One more test available
+    assert_equal(["#{test_name}:test"], (app.tasks - tasks_before).map{|x|x.name} )
+    assert_kind_of(Rake::Task, app["#{test_name}:test"])    
+    
+  end #test_test_task()
+  def test_mk_gem()
+    
+    app = Rake.application
+    test_name = 'test_mk_gem' #test gem for this test. Must be uniq for all tests
+    gemdef = Gem_packer.new(test_name, '0.1.0'){|gem,spec|
+      spec.author = 'Author'
+      spec.email = 'Email'
+      spec.homepage = 'http://www.rubypla.net'
+      spec.summary = 'Summary'
+      spec.description = 'Description'
+      spec.rubyforge_project = 'test'
+    }
+    
+    assert_equal(false, File.exist?("#{gemdef.spec.full_name}.gem"))
+    Frame_catch_output.catch_stdout{
+      app["#{test_name}:gem"].invoke
+    }
+    assert_equal(true, File.exist?("#{gemdef.spec.full_name}.gem"))
+    
+    File.delete("#{gemdef.spec.full_name}.gem")
+  end
+  
+  def test_mk_install()
+    #no testcases
+  end #test_mk_install()
+  def test_ftp_rdoc()
+    app = Rake.application
+    test_name = 'test_ftp_rdoc' #test gem for this test. Must be uniq for all tests
+    gemdef = nil
+    Frame_catch_output.catch_stdout{
+      gemdef = Gem_packer.new(test_name, '0.1.0')
+    }
+    assert_kind_of(Rake::Task, app["#{test_name}:ftp_rdoc"] )
+    assert_raise(Gem_packer::BlockError){ app["#{test_name}:ftp_rdoc"].invoke }
+    
+    gemdef.public = true  #Now it should be possible (but without add_ftp_connection nothing will happen)
+    assert_nothing_raised(Gem_packer::BlockError){ app["#{test_name}:ftp_rdoc"].invoke }
+    
+    #no further testcases
+  end #test_mk_push()
+  def test_mk_push()
+    app = Rake.application
+    test_name = 'test_push' #test gem for this test. Must be uniq for all tests
+    gemdef = nil
+    Frame_catch_output.catch_stdout{
+      gemdef = Gem_packer.new(test_name, '0.1.0'){|gem,spec|
+        spec.author = 'Author'
+        spec.email = 'Email'
+        spec.homepage = 'http://www.rubypla.net'
+        spec.summary = 'Summary'
+        spec.description = 'Description'
+        spec.rubyforge_project = 'test'
+      }
+      app["#{test_name}:gem"].invoke  #call prerequisite for push
+    }
+    assert_kind_of(Rake::Task, app["#{test_name}:push"] )
+    assert_raise(Gem_packer::BlockError){ app["#{test_name}:push"].invoke }
+    assert_nothing_raised{ File.delete(gemdef.spec.full_name + '.gem') }
+    #not tested. else we "push" the test
+    #~ gemdef.public = true  #Now it should be possible
+    #~ assert_nothing_raised(Gem_packer::BlockError){ app["#{test_name}:ftp_rdoc"].invoke }
+    
+    #no further testcases
+  end #test_mk_push()
+
+end

data/unittest/test_rake_testtask.rb

@@ -0,0 +1,105 @@
+$:.unshift('../lib') if $0 == __FILE__
+
+#~ gem 'rake', '= 0.8.7'
+#~ gem 'test-unit', '= ???'
+require 'test/unit'
+require 'knut_tools/catch_output'
+require 'knut_tools/rake/testtask.rb'
+require 'rake/clean'
+
+=begin
+C:\Program Files\ruby\lib\ruby\gems\1.8\gems\rake-0.8.7\lib\rake
+C:\Program Files\Ruby19\lib\ruby\gems\1.9.1\gems\rake-0.8.7\lib\rake
+
+Problem:
+Test lesen Datei. 
+Mit Rake::TestTask.new ist kein Verzeichniswechsel m�glich.
+
+=end
+
+$testdir = "testdir"
+$testfile = "my_test.rb"
+
+#
+#Build the testfile
+#
+desc 'Make the testdata'
+task :mk_testdata do
+  Dir.mkdir($testdir) unless File.directory?($testdir)
+  File.open('hello_world.txt', 'w'){ |f| f << 'Hello World'}
+  File.open("#{$testdir}/#{$testfile}", 'w'){ |f| f << <<testscript
+require 'test/unit'
+
+class Test__xx < Test::Unit::TestCase
+  def test_xx()
+    assert_equal(true, File.exist?('../hello_world.txt'))
+  end #
+end
+testscript
+}
+end
+
+desc 'Delete the testfiles'
+CLOBBER.include(['hello_world.txt', $testdir])
+
+Rake::TestTask.new(:test_ok) do |t|
+    t.dir = $testdir
+    t.test_files = [$testfile].flatten
+    t.verbose = true
+end
+=begin
+This test stopps with a "not found error"
+  Class: <Errno::ENOENT>
+  Message: <"No such file or directory - testdir">
+=end
+Rake::TestTask.new(:test_err) do |t|
+    t.test_files = ["#{$testdir}/#{$testfile}"]
+    t.verbose = true
+end
+
+task :default => :mk_testdata
+task :default => :test_ok
+#~ task :default => :test_err #makes an error
+task :default => :clobber
+
+if $0 == __FILE__
+  #~ app = Rake.application
+  #~ app[:default].invoke
+end
+
+
+class Test_testtask < Test::Unit::TestCase  
+  def test_rake_testtask_def()
+    assert_equal(true, Rake::TestTask.new.respond_to?(:'dir='))
+  end
+  
+  def test_rake_testtask()
+    app = Rake.application
+    app[:mk_testdata].invoke
+    
+    
+    assert_nothing_raised{ app[:test_ok].invoke }
+      
+      
+    notify("Frame_catch_output.catch_screen_output does not work as expected with ruby 1.9.1.")
+    stdout, stderr = Frame_catch_output.catch_screen_output{ 
+      assert_nothing_raised{ app[:test_ok].invoke }
+    }
+    assert_match( %r{Loaded suite .*lib/rake/rake_test_loader
+Started
+.
+Finished in .* seconds.
+
+1 tests, 1 assertions, 0 failures, 0 errors}, stdout)
+
+
+    Frame_catch_output.catch_screen_output{ 
+      assert_raise(RuntimeError){ app[:test_err].invoke }
+    }
+    Frame_catch_output.catch_stderr{ 
+      app[:clobber].invoke
+    }
+    #~ assert_raise(Errno::ENOENT){ app[:test_err].invoke }
+    #~ assert_equal_filecontent( "/test.txt", DUMMYTEXT )    
+  end
+end 

data/unittest/test_required_what.rb

@@ -0,0 +1,72 @@
+=begin rdoc
+This function is only for Ruby 1.8.
+Ruby 1.9 includes already the full name of the included packages.
+
+=end
+if RUBY_VERSION =~ /1.9/
+  puts "Obsolte function for Ruby #{RUBY_VERSION}"
+  exit 
+end
+
+require 'test/unit'
+
+
+
+$:.unshift('../lib') if $0 == __FILE__
+require 'knut_tools/catch_output'
+require 'knut_tools/required_what'
+
+
+class Test_required_what < Test::Unit::TestCase  
+  def test_system()
+    assert_equal($:, $LOAD_PATH)
+    assert_equal($", $LOADED_FEATURES)
+    assert_equal("global-variable", defined? $LOADED_FEATURES_FULL)
+    #~ assert_equal([], $LOADED_FEATURES_FULL)
+  end
+
+  def test_load()
+    
+    before = $LOADED_FEATURES.dup
+    before_full = $LOADED_FEATURES_FULL.dup
+    
+    Frame_catch_output.catch_stdout{ 
+      assert_nothing_raised{ require 'testdata/hello_world' }
+    }
+    
+    assert_equal(["testdata/hello_world.rb"], $LOADED_FEATURES - before)
+    assert_equal(["./testdata/hello_world.rb"], $LOADED_FEATURES_FULL - before_full)
+    
+  end
+
+  def test_load_again()
+    
+    load_result = nil
+    before = $LOADED_FEATURES_FULL.dup
+    
+    assert_nothing_raised{
+      load_result = require 'knut_tools/catch_output'
+    }
+    assert_equal( false,  load_result)
+    assert_equal([], $LOADED_FEATURES_FULL - before)
+    
+  end
+
+  def test_singleton()
+
+    load_result = nil
+    before = $LOADED_FEATURES_FULL.dup
+    File.open('singleton.rb', 'w'){} unless File.exist?('singleton.rb')
+    
+    load_result = require 'singleton.rb'
+    #If called from rakefile, singleton already loaded.
+    if load_result
+      assert_equal("C:/Program Files/ruby/lib/ruby/1.8/singleton.rb", ($LOADED_FEATURES_FULL - before).last)
+      assert_match(%r{Filename conflict in require: singleton.rb: \[.*singleton.rb\", \"./singleton.rb\"\]}, $LOADED_FEATURES_WARN.last )
+    end
+
+    File.delete('singleton.rb')
+
+  end
+end
+

data/unittest/test_yaml.rb

@@ -0,0 +1,144 @@
+require 'test/unit'
+require 'more_unit_test/assert_stdout.rb'
+
+$: << '../lib' if $0 == __FILE__
+require 'knut_tools/yaml'
+
+#~ $expected = File.dirname(__FILE__) + '/tmp_expected'
+#~ $folder_for_failure  = File.dirname(__FILE__) + '/tmp_failure'
+
+
+class Test_knut_tools_yaml < Test::Unit::TestCase  
+  def test_yaml_load_with_warning()
+    assert_stdout_block("!YAML.load: Double Hash-key: a\n"){YAML.load_with_warning(<<-xx
+              a: A
+              a: A
+            xx
+          )}
+    assert_stdout_block("!YAML.load: Double Hash-key: 1\n"){YAML.load_with_warning(<<-xx
+            1: [ eins, one, un, une ]
+            2: [ zwei, two, deux ]
+            3: 
+              foo: bar
+              baz: foo
+            1: [ eins ]
+            10: zehn
+            0xA: zehn, aber hex
+            xx
+          )}
+  end #test_yaml_load_with_warning
+  #
+  #Unfortenatly only level 1.
+  #
+  def test_yaml_load_with_warning_2()
+    assert_stdout_block(""){YAML.load_with_warning(<<-xx
+            1: 
+              a: A
+              a: A
+            xx
+          )}
+    assert_stdout_block(""){YAML.load_with_warning(<<-xx
+            - 
+              a: A
+              a: A
+            xx
+          )}
+  end
+end #Test_knut_tools
+
+class Test_knut_tools_yaml_hash < Test::Unit::TestCase  
+  
+  Hash1 = { 2 => :two, 1 => :one }
+  Hash2 = { 'zwei'  => 2, 'eins' => 1 }
+  ListWithHash = [ Hash1, Hash2 ]
+  
+  #
+  #Default is "sorted"
+  #
+  def test_hash_default()
+    assert_equal(
+      "--- \n1: :one\n2: :two\n",
+        Hash1.to_yaml
+    )
+    assert_equal(
+      "--- \neins: 1\nzwei: 2\n",
+        Hash2.to_yaml
+    )
+  end #test_hash_default()
+  def test_ListWithHash()
+    assert_equal(
+      "--- \n- 1: :one\n  2: :two\n- eins: 1\n  zwei: 2\n",
+        ListWithHash.to_yaml
+    )
+  end #test_ListWithHash()
+  def test_hash_without_hash()
+    assert_nothing_raised{[2,1].to_yaml}
+    assert_nothing_raised{'aaa'.to_yaml}
+    assert_nothing_raised{%w{a b c d e}.to_yaml}
+  end
+  def test_hash_true()
+    assert_equal(
+      "--- \n1: :one\n2: :two\n",
+        Hash1.to_yaml(:SortKeys	=>	true)
+    )
+    assert_equal(
+      "--- \neins: 1\nzwei: 2\n",
+        Hash2.to_yaml(:SortKeys	=>	true)
+    )
+  end
+  #
+  #This result may change. There is no fixed behaviuor
+  #
+  def test_hash_false()
+    #~ assert_equal(
+      #~ "--- \n1: :one\n2: :two\n",
+        #~ Hash1.to_yaml(:SortKeys	=>	false)
+    #~ )
+    #~ assert_equal(
+      #~ "--- \nzwei: 2\neins: 1\n",
+        #~ Hash2.to_yaml(:SortKeys	=>	false),
+        #~ "Result may change"
+    #~ )
+  end
+  def test_hash_symbols()
+    hash_sym = { :b => 'B', :a => 'A' }
+    assert_equal(
+      "--- \n:a: A\n:b: B\n",
+        hash_sym.to_yaml(:SortKeys	=>	true)
+    )
+    #random the same
+    assert_equal(
+      "--- \n:a: A\n:b: B\n",
+        hash_sym.to_yaml(:SortKeys	=>	false)
+    )
+  end
+  def test_hash_symbols()
+    hash_sym_mix = { :b => 'B', 'a' => 'A' }
+    assert_equal(
+      "--- \na: A\n:b: B\n",
+        hash_sym_mix.to_yaml(:SortKeys	=>	true)
+    )
+    #by random the same
+    assert_equal(
+      "--- \na: A\n:b: B\n",
+        hash_sym_mix.to_yaml(:SortKeys	=>	false)
+    )
+  end
+  def test_hash_mix_num()
+    hash_sym_mix = { 2 => 2, 1 => 1, '10' => 10 }
+    assert_equal(
+      "--- \n1: 1\n\"10\": 10\n2: 2\n",
+        hash_sym_mix.to_yaml(:SortKeys	=>	true)
+    )
+    #by random the same
+    #~ assert_equal(
+      #~ "--- \n1: 1\n2: 2\n\"10\": 10\n",
+        #~ hash_sym_mix.to_yaml(:SortKeys	=>	false),
+      #~ "Result may change"
+    #~ )
+  end
+end
+
+__END__
+- first item
+- second item