gettalong-webgen 0.5.4.20080929

data/test/test_contentprocessor_haml.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorHaml < Test::Unit::TestCase
+
+  def test_call
+    obj = Webgen::ContentProcessor::Haml.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => "#content\n  %h1 Hallo\n  = node.absolute_lcn",
+                                                    :chain => [node])
+    obj.call(context)
+    assert_equal("<div id='content'>\n  <h1>Hallo</h1>\n  /test\n</div>\n", context.content)
+
+    context.content = "#cont\n  = unknown"
+    assert_raise(RuntimeError) { obj.call(context) }
+  end
+
+end

data/test/test_contentprocessor_maruku.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'webgen/node'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorMaruku < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::ContentProcessor::Maruku.new
+    node = Webgen::Node.new(Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/'), 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => '# header', :chain => [node])
+    assert_equal('<h1 id=\'header\'>header</h1>', @obj.call(context).content)
+
+    context.content = "# head*d* {#das .dsaf "
+    assert_raise(RuntimeError) { @obj.call(context)}
+  end
+
+  def test_call_fix_for_invalid_id
+    @obj = Webgen::ContentProcessor::Maruku.new
+    context = Webgen::ContentProcessor::Context.new(:content => '# `test`')
+    assert_equal('<h1 id=\'id1\'><code>test</code></h1>', @obj.call(context).content)
+
+    context = Webgen::ContentProcessor::Context.new(:content => '# `test`')
+    assert_equal('<h1 id=\'id1\'><code>test</code></h1>', @obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_rdiscount.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'webgen/node'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorRDiscount < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::ContentProcessor::RDiscount.new
+    node = Webgen::Node.new(Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/'), 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => '# header', :chain => [node])
+    assert_equal("<h1>header</h1>\n", @obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_rdoc.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorRDoc < Test::Unit::TestCase
+
+  def test_call
+    obj = Webgen::ContentProcessor::RDoc.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => "* hello",
+                                                    :chain => [node])
+    assert_equal("<ul>\n<li>hello\n\n</li>\n</ul>\n", obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_redcloth.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorRedCloth < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::ContentProcessor::RedCloth.new
+    context = Webgen::ContentProcessor::Context.new(:content => 'h1. header')
+    assert_equal('<h1>header</h1>', @obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_sass.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorSass < Test::Unit::TestCase
+
+  def test_call
+    obj = Webgen::ContentProcessor::Sass.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => "#main\n  :background-color #000",
+                                                    :chain => [node])
+    obj.call(context)
+    assert_equal("#main {\n  background-color: #000; }\n", context.content)
+
+    context.content = "#cont \n = unknown"
+    assert_raise(RuntimeError) { obj.call(context) }
+  end
+
+end

data/test/test_contentprocessor_tags.rb

@@ -0,0 +1,97 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor/tags'
+
+class TestContentProcessorTags < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  class TestTag
+
+    def set_params(*args); end
+
+    def create_tag_params(*args); end
+
+    def call(tag, body, context)
+      case tag
+      when 'body'
+        body
+      when 'bodyproc'
+        [body, true]
+      else
+        tag
+      end
+    end
+
+  end
+
+  def setup
+    super
+    @obj = Webgen::ContentProcessor::Tags.new
+    @website.config['contentprocessor.tags.map'].delete(:default)
+  end
+
+  def test_call
+    context = Webgen::ContentProcessor::Context.new(:chain => [Webgen::Tree.new.dummy_root])
+    context.content = "{test: }"
+    assert_equal('', @obj.call(context).content)
+
+    add_test_tag
+    assert_equal('test', @obj.call(context.clone(:content => "{test: }")).content)
+    assert_equal('thebody', @obj.call(context.clone(:content => "{body::}thebody{body}")).content)
+    assert_equal('test {other:}other test',
+                  @obj.call(context.clone(:content => "test{bodyproc::} \\{other:}{other:} {bodyproc}test")).content)
+  end
+
+  def test_replace_tags
+    check_returned_tags('sdfsdf{asd', [])
+    check_returned_tags('sdfsdf}asd', [])
+    check_returned_tags('sdfsdf{asd}', [])
+    check_returned_tags('sdfsdf{asd: {}as', [])
+    check_returned_tags('sdfsdf{test: {test1: }}', [['test', ' {test1: }', '']], 'sdfsdftest1')
+    check_returned_tags('sdfsdf{test: {test1: {}}', [['test', '', '']], 'sdfsdf{test: {test1: {}}')
+    check_returned_tags('sdfsdf{test:}{test1: }', [['test', '', ''], ['test1', ' ', '']], 'sdfsdftest1test2')
+    check_returned_tags('sdfsdf{test:}\\{test1: }', [['test', '', '']], "sdfsdftest1{test1: }")
+    check_returned_tags('sdfsdf\\{test:}{test1:}', [['test1', '', '']], "sdfsdf{test:}test1")
+    check_returned_tags('sdfsdf{test: asdf}', [['test', ' asdf', '']], "sdfsdftest1")
+    check_returned_tags('sdfsdf\\{test: asdf}', [], "sdfsdf{test: asdf}")
+    check_returned_tags('sdfsdf\\\\{test: asdf}', [['test', ' asdf', '']], "sdfsdf\\test1")
+    check_returned_tags('sdfsdf\\\\\\{test: asdf}sdf', [['test', ' asdf', '']], "sdfsdf\\{test: asdf}sdf")
+
+    check_returned_tags('before{test::}body{test}', [['test', '', 'body']], "beforetest1")
+    check_returned_tags('before{test::}body{testno}', [], "before{test::}body{testno}")
+    check_returned_tags('before{test::}body\\{test}other{test}', [['test', '', 'body{test}other']], "beforetest1")
+    check_returned_tags('before{test::}body\\{test}{test}', [['test', '', 'body{test}']], "beforetest1")
+    check_returned_tags('before{test::}body\\{test}\\\\{test}after', [['test', '', 'body{test}\\']], "beforetest1after")
+    check_returned_tags('before\\{test::}body{test}', [['test', '', 'body']], "before{test::}body{test}")
+    check_returned_tags('before\\\\{test:: asdf}body{test}after', [['test', ' asdf', 'body']], "before\\test1after")
+  end
+
+  def test_processor_for_tag
+    assert_nil(@obj.instance_eval { processor_for_tag('test') })
+    assert_nil(@obj.instance_eval { processor_for_tag(:default) })
+    add_test_tag
+    assert_not_nil(@obj.instance_eval { processor_for_tag(:default) })
+  end
+
+  private
+
+  def add_test_tag
+    @website.config['contentprocessor.tags.map'].update(:default => 'TestContentProcessorTags::TestTag')
+  end
+
+  def check_returned_tags(content, data, result = content)
+    i = 0
+    check_proc = proc do |tag, params, body|
+      assert_equal(data[i][0], tag, 'tag: ' + content)
+      assert_equal(data[i][1], params, 'params: ' + content)
+      assert_equal(data[i][2], body, 'body: ' + content)
+      i += 1
+      'test' + i.to_s
+    end
+    assert_equal(result, @obj.instance_eval { replace_tags(content, Webgen::Tree.new.dummy_root, &check_proc) })
+    assert(i, data.length)
+  end
+
+end

data/test/test_languages.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+require 'webgen/languages'
+
+class TestLanguages < Test::Unit::TestCase
+
+  def test_get_language
+    assert_nil(Webgen::LanguageManager.language_for_code(nil))
+
+    lang1 = Webgen::LanguageManager.language_for_code('ger')
+    lang2 = Webgen::LanguageManager.language_for_code('deu')
+    lang3 = Webgen::LanguageManager.language_for_code('de')
+    lang4 = Webgen::LanguageManager.language_for_code('en')
+
+    [lang1, lang2, lang3, lang4].each {|lang| assert_kind_of(Webgen::Language, lang)}
+    assert_equal(lang1, lang2)
+    assert_equal(lang3, lang2)
+    assert_not_equal(lang4, lang2)
+  end
+
+  def test_find_language
+    langs = Webgen::LanguageManager.find_language('greek')
+    assert_equal(2, langs.length)
+    assert_equal('gre', langs[0].code3chars)
+    assert_equal('grc', langs[1].code3chars)
+  end
+
+  def test_language_accessors
+    lang = Webgen::LanguageManager.language_for_code('ger')
+    assert_equal('ger', lang.code3chars)
+    assert_equal('deu', lang.code3chars_alternative)
+    assert_equal('de', lang.code2chars)
+  end
+
+  def test_other_methods
+    de = Webgen::LanguageManager.language_for_code('ger')
+    assert_equal('de', de)
+    assert_equal(de, 'de')
+    assert_equal("de", de.to_s)
+    assert_equal("Implicitly de", "Implicitly " + de)
+    assert_kind_of(String, de.inspect)
+  end
+
+  def test_sort_method
+    ger = Webgen::LanguageManager.language_for_code('ger')
+    eng = Webgen::LanguageManager.language_for_code('en')
+    ace = Webgen::LanguageManager.language_for_code('ace')
+
+    assert_equal(-1, ger <=> eng)
+    assert_equal(-1, ace <=> ger)
+    assert_equal(-1, ace <=> eng)
+  end
+
+end

data/test/test_loggable.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/loggable'
+require 'webgen/logger'
+require 'stringio'
+
+class TestLoggable < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @website.logger = Webgen::Logger.new(@io = StringIO.new, true)
+    @obj = Object.new
+    @obj.extend(Webgen::Loggable)
+  end
+
+  def test_log
+    @obj.log(:error) { 'hallo' }
+    assert_equal("ERROR -- hallo\n", @io.string)
+  end
+
+  def test_puts
+    @obj.puts 'test'
+    assert_equal("test\n", @io.string)
+    @obj.puts 'test', :verbose
+    assert_equal("test\n", @io.string)
+  end
+
+end

data/test/test_logger.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/logger'
+
+class TestLogger < Test::Unit::TestCase
+
+  def test_initialize
+    l = Webgen::Logger.new(io = StringIO.new)
+    assert_equal(:normal, l.verbosity)
+    assert_equal(::Logger::WARN, l.level)
+    assert_equal(false, l.sync)
+  end
+
+  def test_setters
+    l = Webgen::Logger.new(io = StringIO.new)
+    l.verbosity = :quiet
+    l.level = ::Logger::DEBUG
+    assert_equal(::Logger::DEBUG, l.level)
+    assert_equal(:quiet, l.verbosity)
+  end
+
+  def test_log_sync
+    l = Webgen::Logger.new(io = StringIO.new, true)
+    l.error { 'error' }
+    l.stdout { 'hallo' }
+    l.warn { 'warn' }
+    l.info { 'info' }
+    l.debug { 'debug' }
+    assert_equal("ERROR -- error\nhallo\n WARN -- warn\n", io.string)
+  end
+
+  def test_log_async
+    l = Webgen::Logger.new(io = StringIO.new, false)
+    l.error { 'error' }
+    l.stdout { 'hallo' }
+    assert_equal("hallo\n", io.string)
+  end
+
+  def test_verbosity_levels
+    l = Webgen::Logger.new(io = StringIO.new)
+    l.verbose { 'vrb'}
+    l.stdout { 'std' }
+    assert_equal("std\n", io.string)
+
+    io.string = ''
+    l.verbosity = :verbose
+    l.verbose { 'vrb' }
+    assert_equal("vrb\n", io.string)
+
+    io.string = ''
+    l.verbosity = :quiet
+    l.stdout { 'vrb' }
+    assert_equal("", io.string)
+  end
+
+  def test_debug_format
+    l = Webgen::Logger.new(io = StringIO.new, true)
+    l.level = ::Logger::DEBUG
+    l.info('source') { 'hallo' }
+    assert_equal(" INFO -- source: hallo\n", io.string)
+  end
+
+  def test_log_output
+    l = Webgen::Logger.new(io = StringIO.new, true)
+    l.error { 'hallo' }
+    assert_equal('', l.log_output)
+
+    l = Webgen::Logger.new(io = StringIO.new, false)
+    l.error { 'hallo' }
+    assert_equal("ERROR -- hallo\n", l.log_output)
+  end
+
+end

data/test/test_node.rb

@@ -0,0 +1,339 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/node'
+require 'webgen/tree'
+
+class TestNode < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @tree = Webgen::Tree.new
+  end
+
+  def create_default_nodes
+    {
+      :root => node = Webgen::Node.new(@tree.dummy_root, '/', '/'),
+      :somename_en => child_en = Webgen::Node.new(node, '/somename.en.html', 'somename.page', {'lang' => 'en', 'title' => 'somename'}),
+      :somename_de => child_de = Webgen::Node.new(node, '/somename.de.html', 'somename.page', {'lang' => 'de'}),
+      :other => Webgen::Node.new(node, '/other.html', 'other.page', {}),
+      :other_en => Webgen::Node.new(node, '/other1.html', 'other.page', {'lang' => 'en'}),
+      :somename_en_frag => frag_en = Webgen::Node.new(child_en, '/somename.en.html#frag', '#othertest', {'title' => 'frag'}),
+      :somename_de_frag => Webgen::Node.new(child_de, '/somename.de.html#frag', '#othertest'),
+      :somename_en_fragnest => Webgen::Node.new(frag_en, '/somename.en.html#fragnest', '#nestedpath'),
+      :dir => dir = Webgen::Node.new(node, '/dir/', 'dir/'),
+      :dir_file => dir_file = Webgen::Node.new(dir, '/dir/file.html', 'file.html'),
+      :dir_file_frag => Webgen::Node.new(dir_file, '/dir/file.html#frag', '#frag'),
+      :dir2 => dir2 = Webgen::Node.new(node, '/dir2/', 'dir2/', {'index_path' => 'index.html', 'title' => 'dir2'}),
+      :dir2_index_en => Webgen::Node.new(dir2, '/dir2/index.html', 'index.html', {'lang' => 'en', 'routed_title' => 'routed', 'title' => 'index'}),
+      :dir2_index_de => Webgen::Node.new(dir2, '/dir2/index.de.html', 'index.html', {'lang' => 'de', 'routed_title' => 'routed_de', 'title' => 'index'}),
+    }
+  end
+
+  def test_initialize
+    check_proc = proc do |node, parent, path, cn, lcn, alcn, lang, mi|
+      assert_equal(parent, node.parent)
+      assert_equal(path, node.path)
+      assert_equal(cn, node.cn)
+      assert_equal(lcn, node.lcn)
+      assert_equal(alcn, node.absolute_lcn)
+      assert_equal(lang, node.lang)
+      assert(node.dirty)
+      assert(node.created)
+      assert_equal(mi, node.meta_info)
+      assert_equal({:used_nodes => Set.new, :used_meta_info_nodes => Set.new}, node.node_info)
+      mi.each {|k,v| assert_equal(v, node[k])}
+    end
+
+    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    check_proc.call(node, @tree.dummy_root, 'test/', 'test', 'test', '/test', nil, {:test => :value})
+
+    child = Webgen::Node.new(node, 'somename.html', 'somename.page',  {'lang' => 'de'})
+    check_proc.call(child, node, 'somename.html', 'somename.page', 'somename.de.page',
+                    '/test/somename.de.page', 'de', {})
+
+    ['http://webgen.rubyforge.org', 'c:\\test'].each_with_index do |abspath, index|
+      cn = 'test' + index.to_s + '.html'
+      child = Webgen::Node.new(node, abspath, cn)
+      check_proc.call(child, node, abspath, cn, cn, '/test/' + cn, nil, {})
+    end
+  end
+
+  def test_type_checkers
+    nodes = create_default_nodes
+    assert(nodes[:root].is_directory?)
+    assert(nodes[:somename_en].is_file?)
+    assert(nodes[:somename_en_frag].is_fragment?)
+    assert(nodes[:root].is_root?)
+    assert(!nodes[:somename_en].is_root?)
+  end
+
+  def test_meta_info_assignment
+    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    node[:test] = :newvalue
+    node[:other] = :value
+    assert_equal(:newvalue, node[:test])
+    assert_equal(:value, node[:other])
+  end
+
+  def test_in_lang
+    nodes = create_default_nodes
+
+    assert_equal(nodes[:somename_de], nodes[:somename_en].in_lang('de'))
+    assert_equal(nodes[:somename_en], nodes[:somename_en].in_lang('en'))
+    assert_equal(nodes[:somename_en], nodes[:somename_de].in_lang('en'))
+    assert_equal(nil, nodes[:somename_de].in_lang('fr'))
+    assert_equal(nil, nodes[:somename_en].in_lang(nil))
+
+    assert_equal(nodes[:other_en], nodes[:other].in_lang('en'))
+    assert_equal(nodes[:other], nodes[:other].in_lang('de'))
+    assert_equal(nodes[:other], nodes[:other].in_lang(nil))
+    assert_equal(nodes[:other], nodes[:other_en].in_lang(nil))
+    assert_equal(nodes[:other], nodes[:other_en].in_lang('de'))
+
+    assert_equal(nil, nodes[:somename_en_frag].in_lang(nil))
+    assert_equal(nodes[:somename_en_frag], nodes[:somename_en_frag].in_lang('en'))
+    assert_equal(nodes[:somename_de_frag], nodes[:somename_en_frag].in_lang('de'))
+  end
+
+  def test_resolve
+    nodes = create_default_nodes
+
+    [nodes[:root], nodes[:somename_de], nodes[:somename_en], nodes[:other]].each do |n|
+      assert_equal(nil, n.resolve('somename.page', nil))
+      assert_equal(nodes[:somename_en], n.resolve('somename.page', 'en'))
+      assert_equal(nodes[:somename_de], n.resolve('somename.page', 'de'))
+      assert_equal(nil, n.resolve('somename.page', 'fr'))
+      assert_equal(nodes[:somename_en], n.resolve('somename.en.page', nil))
+      assert_equal(nodes[:somename_en], n.resolve('somename.en.page', 'en'))
+      assert_equal(nodes[:somename_en], n.resolve('somename.en.page', 'de'))
+      assert_equal(nil, n.resolve('somename.fr.page', 'de'))
+
+      assert_equal(nodes[:other], n.resolve('other.page', nil))
+      assert_equal(nodes[:other], n.resolve('other.page', 'fr'))
+      assert_equal(nodes[:other_en], n.resolve('other.page', 'en'))
+      assert_equal(nodes[:other_en], n.resolve('other.en.page', nil))
+      assert_equal(nodes[:other_en], n.resolve('other.en.page', 'de'))
+      assert_equal(nil, n.resolve('other.fr.page', nil))
+      assert_equal(nil, n.resolve('other.fr.page', 'en'))
+    end
+
+    assert_equal(nodes[:somename_en_frag], nodes[:somename_en].resolve('#othertest', 'de'))
+    assert_equal(nodes[:somename_en_frag], nodes[:somename_en].resolve('#othertest', nil))
+    assert_equal(nodes[:somename_en_fragnest], nodes[:somename_en].resolve('#nestedpath', nil))
+
+    assert_equal(nil, nodes[:root].resolve('/somename.page#othertest', nil))
+    assert_equal(nodes[:somename_en_frag], nodes[:root].resolve('/somename.page#othertest', 'en'))
+    assert_equal(nodes[:somename_de_frag], nodes[:root].resolve('/somename.page#othertest', 'de'))
+    assert_equal(nodes[:somename_en_frag], nodes[:root].resolve('/somename.en.page#othertest'))
+    assert_equal(nodes[:somename_de_frag], nodes[:root].resolve('/somename.de.page#othertest'))
+
+    assert_equal(nil, nodes[:dir2].resolve('index.html'))
+    assert_equal(nodes[:dir2_index_en], nodes[:dir2].resolve('index.html', 'en'))
+
+    assert_equal(nodes[:dir], nodes[:somename_en].resolve('/dir/'))
+    assert_equal(nodes[:root], nodes[:somename_en].resolve('/'))
+  end
+
+  def test_introspection
+    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    assert(node.inspect =~ /alcn=\/test/)
+  end
+
+  def test_changed
+    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    node.dirty = node.created = false
+
+    calls = 0
+    @website.blackboard.add_listener(:node_changed?) {|n| assert(node, n); node.dirty = true; calls += 1}
+    node.changed?
+    assert_equal(1, calls)
+    node.changed?
+    assert_equal(1, calls)
+
+    node.dirty = false
+    node.node_info[:used_nodes] << node.absolute_lcn
+    node.node_info[:used_nodes] << 'unknown alcn'
+    node.node_info[:used_nodes] << @tree.dummy_root.absolute_lcn
+    node.changed?
+    assert_equal(1, calls)
+
+    # Test circular depdendence
+    other_node = Webgen::Node.new(@tree.dummy_root, '/other', 'test.l', {'lang' => 'de', :test => :value})
+    other_node.dirty = node.created = false
+    node.dirty = false
+    other_node.node_info[:used_nodes] = [node.absolute_lcn]
+    node.node_info[:used_nodes] = [other_node.absolute_lcn]
+    node.changed?
+  end
+
+  def test_meta_info_changed
+    node = Webgen::Node.new(@tree.dummy_root, '/', '/')
+    node.dirty = node.created = false
+
+    calls = 0
+    @website.blackboard.add_listener(:node_meta_info_changed?) {|n| assert(node, n); node.dirty_meta_info = true; calls += 1}
+    assert(node.meta_info_changed?)
+    assert_equal(1, calls)
+    assert(node.meta_info_changed?)
+    assert_equal(1, calls)
+
+    node.dirty_meta_info = false
+    node.node_info[:used_meta_info_nodes] << node.absolute_lcn
+    node.node_info[:used_meta_info_nodes] << 'unknown alcn'
+    node.node_info[:used_meta_info_nodes] << @tree.dummy_root.absolute_lcn
+    assert(node.meta_info_changed?)
+    assert_equal(2, calls)
+  end
+
+  def test_method_missing
+    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    assert_raise(NoMethodError) { node.unknown }
+    obj = @website.cache.instance('Object')
+    def obj.doit(node); :value; end
+    node.node_info[:processor] = 'Object'
+    assert_equal(:value, node.doit)
+  end
+
+  def test_matching
+    root = Webgen::Node.new(@tree.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'somefile.de.html', 'somefile.html', {'lang' => 'de'})
+    assert(node =~ '**/*')
+    assert(node =~ '**/somefile.de.HTML')
+    assert(node =~ '/**/somefile.*.html')
+    assert(node !~ '/somefile.html')
+    assert(node !~ '**/*.test')
+  end
+
+  def test_absolute_name
+    root = Webgen::Node.new(@tree.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'somepath', 'somefile.html', {'lang' => 'de'})
+    assert_equal('/somefile.de.html', node.absolute_lcn)
+  end
+
+  def test_route_to
+    nodes = create_default_nodes
+
+    #arg is Node
+    assert_equal('somename.en.html', nodes[:somename_en].route_to(nodes[:somename_en]))
+    assert_equal('somename.de.html', nodes[:somename_en_frag].route_to(nodes[:somename_de]))
+    assert_equal('file.html#frag', nodes[:dir].route_to(nodes[:dir_file_frag]))
+    assert_equal('#frag', nodes[:dir_file].route_to(nodes[:dir_file_frag]))
+    assert_equal('../dir2/index.html', nodes[:dir_file_frag].route_to(nodes[:dir2_index_en]))
+    assert_equal('../dir2/index.html', nodes[:dir_file].route_to(nodes[:dir2_index_en]))
+
+    assert_equal('./', nodes[:somename_en].route_to(nodes[:root]))
+    assert_equal('../', nodes[:dir].route_to(nodes[:root]))
+    assert_equal('dir/', nodes[:somename_en].route_to(nodes[:dir]))
+
+    #arg is String
+    assert_equal('somename.en.html', nodes[:somename_en].route_to('somename.en.html'))
+    assert_equal('../other.html', nodes[:dir_file].route_to('/other.html'))
+    assert_equal('../other', nodes[:dir_file].route_to('../other'))
+    assert_equal('document/file2', nodes[:dir_file_frag].route_to('document/file2'))
+    assert_equal('ftp://test', nodes[:dir].route_to('ftp://test'))
+
+    #test args with '..' and '.': either too many of them or absolute path given
+    assert_equal('../dir2', nodes[:dir_file].route_to('../../.././dir2'))
+    assert_equal('../file', nodes[:dir_file].route_to('/dir/../file'))
+    assert_equal('file', nodes[:dir_file].route_to('dir/../file'))
+
+    #arg is something else
+    assert_raise(ArgumentError) { nodes[:root].route_to(5) }
+  end
+
+  def test_routing_node
+    nodes = create_default_nodes
+
+    assert_equal(nodes[:somename_en], nodes[:somename_en].routing_node('en'))
+
+    assert_equal(nodes[:dir], nodes[:dir].routing_node('en'))
+    assert_equal(nodes[:dir2_index_en], nodes[:dir2].routing_node('en'))
+    assert_equal(nodes[:dir2_index_en], nodes[:dir2].routing_node('en'))
+    @website.cache.volatile.clear
+    nodes[:dir2].meta_info['index_path'] = 'unknown'
+    assert_equal(nodes[:dir2], nodes[:dir2].routing_node('en'))
+  end
+
+  def test_comparision_op
+    nodes = create_default_nodes
+    nodes[:somename_en]['title'] = 'somename'
+    nodes[:other_en]['title'] = 'other'
+
+    assert_equal(0, nodes[:somename_en] <=> nodes[:somename_en])
+    assert_equal(1, nodes[:somename_en] <=> nodes[:other_en])
+    assert_equal(-1, nodes[:other_en] <=> nodes[:somename_en])
+    nodes[:other_en]['sort_info'] = 1
+    assert_equal(1, nodes[:somename_en] <=> nodes[:other_en])
+    nodes[:other_en]['sort_info'] = '2008-06-28'
+    nodes[:somename_en]['sort_info'] = '2008-06-29'
+    assert_equal(1, nodes[:somename_en] <=> nodes[:other_en])
+  end
+
+  def test_level
+    nodes = create_default_nodes
+    assert_equal(0, nodes[:root].level)
+    assert_equal(1, nodes[:dir].level)
+    assert_equal(2, nodes[:dir_file].level)
+    assert_equal(3, nodes[:dir_file_frag].level)
+  end
+
+  def test_in_subtree_of
+    nodes = create_default_nodes
+
+    assert(nodes[:somename_en].in_subtree_of?(nodes[:root]))
+    assert(nodes[:dir].in_subtree_of?(nodes[:root]))
+
+    assert(nodes[:dir_file].in_subtree_of?(nodes[:dir]))
+
+    assert(nodes[:dir_file_frag].in_subtree_of?(nodes[:root]))
+    assert(nodes[:dir_file_frag].in_subtree_of?(nodes[:dir]))
+    assert(nodes[:dir_file_frag].in_subtree_of?(nodes[:dir_file]))
+
+    assert(!nodes[:dir2_index_en].in_subtree_of?(nodes[:dir]))
+    assert(!nodes[:somename_en].in_subtree_of?(nodes[:dir]))
+    assert(!nodes[:somename_en].in_subtree_of?(nodes[:dir_file]))
+    assert(!nodes[:dir_file].in_subtree_of?(nodes[:dir2_index_en]))
+  end
+
+  def test_link_to
+    nodes = create_default_nodes
+
+    # general tests
+    assert_equal('<a href="#frag">frag</a>',
+                 nodes[:somename_en].link_to(nodes[:somename_en_frag]))
+    assert_equal('<a href="#frag">link_text</a>',
+                 nodes[:somename_en].link_to(nodes[:somename_en_frag], :link_text => 'link_text'))
+    assert_equal('<a attr1="val1" href="#frag">frag</a>',
+                 nodes[:somename_en].link_to(nodes[:somename_en_frag], 'attr1' => 'val1'))
+    assert_equal('<a href="#frag">frag</a>',
+                 nodes[:somename_en].link_to(nodes[:somename_en_frag], :attr1 => 'val1'))
+    assert_equal('<a href="dir2/index.html">index</a>',
+                 nodes[:somename_en].link_to(nodes[:dir2_index_en]))
+
+    nodes[:somename_en_frag]['link_attrs'] = {:link_text => 'Default Text', 'class'=>'help'}
+    assert_equal('<a attr1="val1" class="help" href="#frag">link_text</a>',
+                 nodes[:somename_en].link_to(nodes[:somename_en_frag], :link_text => 'link_text', 'attr1' => 'val1'))
+
+    # links to directories
+    assert_equal('<a href="dir2/index.de.html">routed_de</a>',
+                 nodes[:somename_de].link_to(nodes[:dir2]))
+    assert_equal('<a href="dir2/index.html">routed</a>',
+                 nodes[:somename_en].link_to(nodes[:dir2]))
+    assert_equal('<a href="dir2/index.de.html">routed_de</a>',
+                 nodes[:somename_en].link_to(nodes[:dir2], :lang => 'de'))
+    assert_equal('<span>routed</span>',
+                 nodes[:dir2_index_en].link_to(nodes[:dir2]))
+
+    # varying the website.link_to_current_page option
+    @website.config['website.link_to_current_page'] = true
+    assert_equal('<a class="help" href="#frag">Default Text</a>',
+                 nodes[:somename_en_frag].link_to(nodes[:somename_en_frag]))
+    @website.config['website.link_to_current_page'] = false
+    assert_equal('<span class="help">Default Text</span>',
+                 nodes[:somename_en_frag].link_to(nodes[:somename_en_frag]))
+  end
+
+
+end