webgen 0.4.7 → 0.5.0

data/test/test_tag_base.rb

@@ -0,0 +1,82 @@
+require 'test/unit'
+require 'helper'
+require 'stringio'
+require 'webgen/tag'
+require 'webgen/tag/base'
+
+class TestTagBase < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  class TestTag; include Webgen::Tag::Base; end
+
+  def setup
+    super
+    @website.config.testtagbase.testtag.param1 'param1'
+    @website.config.testtagbase.testtag.param2 nil, :mandatory=> true
+    @website.config.testtagbase.testtag.param3 'param3', :mandatory => 'default'
+    @obj = TestTag.new
+  end
+
+  def test_tag_config_base
+    assert_equal('testtagbase.testtag', @obj.send(:tag_config_base))
+  end
+
+  def test_tag_params_list
+    params = [1,2,3].collect {|i| 'testtagbase.testtag.param' + i.to_s}
+    assert_equal(params.sort, @obj.send(:tag_params_list).sort)
+  end
+
+  def test_create_tag_params
+    output = StringIO.new('')
+    @website.logger = ::Logger.new(output)
+    @website.logger.level = Logger::WARN
+
+    output.string = ''
+    assert_equal({}, @obj.create_tag_params("--\nhal:param1\ntest:[;", Webgen::Tree.new.dummy_root))
+    output.rewind; assert_match(/Could not parse the tag params/, output.read)
+
+    output.string = ''
+    set_params(5)
+    assert_equal('param1', @obj.param('testtagbase.testtag.param1'))
+    output.rewind; assert_match(/Not all mandatory parameters/, output.read)
+    output.rewind; assert_match(/Invalid parameter type/, output.read)
+
+    output.string = ''
+    set_params(nil)
+    assert_equal('param1', @obj.param('testtagbase.testtag.param1'))
+    output.rewind; assert_match(/Not all mandatory parameters/, output.read)
+
+    output.string = ''
+    set_params({})
+    assert_equal('param1', @obj.param('testtagbase.testtag.param1'))
+    output.rewind; assert_match(/Not all mandatory parameters/, output.read)
+
+    output.string = ''
+    set_params('test_value')
+    assert_equal('test_value', @obj.param('testtagbase.testtag.param3'))
+    output.rewind; assert_match(/Not all mandatory parameters/, output.read)
+
+    output.string = ''
+    set_params({'param2' => 'test2', 'testtagbase.testtag.param3' => 'test3', 'invalid' => 5})
+    assert_equal('test2', @obj.param('testtagbase.testtag.param2'))
+    assert_equal('test3', @obj.param('testtagbase.testtag.param3'))
+    output.rewind; assert_no_match(/Not all mandatory parameters/, output.read)
+    output.rewind; assert_match(/Invalid parameter 'invalid'/, output.read)
+
+    @website.config.data.delete('testtagbase.testtag.param3')
+    @website.config.meta_info.delete('testtagbase.testtag.param3')
+    output.string = ''
+    set_params('default_value')
+    output.rewind; assert_match(/No default mandatory parameter specified for tag/, output.read)
+  end
+
+  def test_call
+    assert_raise(NotImplementedError) { @obj.call(nil, nil, nil) }
+  end
+
+  def set_params(params)
+    @obj.set_params(@obj.send(:create_params_hash, params, Webgen::Tree.new.dummy_root))
+  end
+
+end

data/test/test_tag_menu.rb

@@ -0,0 +1,196 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/tag/menu'
+
+class TestTagMenu < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Tag::Menu.new
+  end
+
+  def create_default_nodes
+    {
+      :root => root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/', {'index_path' => 'index.html'}),
+      :dir1 => dir1 = Webgen::Node.new(root, '/dir1/', 'dir1/'),
+      :dir11 => dir11 = Webgen::Node.new(dir1, '/dir1/dir11/', 'dir11/', {'index_path' => 'index.html'}),
+      :file111_en => Webgen::Node.new(dir11, '/dir1/dir11/file111.en.html', 'file111.html', {'lang' => 'en', 'in_menu' => true}),
+      :file111_de => Webgen::Node.new(dir11, '/dir1/dir11/file111.de.html', 'file111.html', {'lang' => 'de', 'in_menu' => true}),
+      :index11_en => Webgen::Node.new(dir11, '/dir1/dir11/index.en.html', 'index.html', {'lang' => 'en', 'in_menu' => true}),
+      :file11_en => file11 = Webgen::Node.new(dir1, '/dir1/file11.en.html', 'file11.html', {'lang' => 'en', 'in_menu' => true}),
+      :file11_en_f1 => file11_f1 = Webgen::Node.new(file11, '/dir1/file11.en.html#f1', '#f1', {'in_menu' => true}),
+      :file11_en_f11 => Webgen::Node.new(file11_f1, '/dir1/file11.en.html#f11', '#f11', {'in_menu' => true}),
+      :file11_en_f2 => Webgen::Node.new(file11, '/dir1/file11.en.html#f2', '#f2', {'in_menu' => true}),
+      :dir2 => dir2 = Webgen::Node.new(root, '/dir2/', 'dir2/'),
+      :file21_en => Webgen::Node.new(dir2, '/dir2/file21.en.html', 'file21.html', {'lang' => 'en', 'in_menu' => true}),
+      :dir3 => dir3 = Webgen::Node.new(root, '/dir3/', 'dir3/'),
+      :file31_en => file31 = Webgen::Node.new(dir3, '/dir3/file31.en.html', 'file31.html', {'lang' => 'en', 'in_menu' => false}),
+      :file31_en_f1 => Webgen::Node.new(file31, '/dir3/file31.en.html#f1', '#f1', {'in_menu' => true}),
+      :file1_de => Webgen::Node.new(root, '/file1.de.html', 'file1.html', {'lang' => 'de', 'in_menu' => true}),
+      :index_en => Webgen::Node.new(root, '/index.en.html', 'index.html', {'lang' => 'en'}),
+    }
+  end
+
+  def build_menu(node, options)
+    @obj.set_params(options_hash(*options))
+    output = @obj.send(:specific_menu_tree_for, node)
+    @obj.set_params({})
+    output
+  end
+
+  def options_hash(start_level, min_levels, max_levels, subtree, used_nodes = 'all')
+    {'tag.menu.start_level' => start_level, 'tag.menu.min_levels' => min_levels, 'tag.menu.max_levels' => max_levels,
+      'tag.menu.show_current_subtree_only' => subtree, 'tag.menu.used_nodes' => used_nodes }
+  end
+
+  def test_call
+    nodes = create_default_nodes
+
+    output = @obj.call('menu', '', Webgen::ContentProcessor::Context.new(:chain => [nodes[:file11_en]]))
+    assert_equal("<div class=\"webgen-menu\">" +
+                 "<ul><li class=\"webgen-menu-submenu webgen-menu-submenu-inhierarchy\"><a href=\"./\"></a>" +
+                 "<ul><li class=\"webgen-menu-submenu\"><a href=\"dir11/index.en.html\"></a></li>" +
+                 "<li class=\"webgen-menu-item-selected\"><span></span></li></ul></li>" +
+                 "<li class=\"webgen-menu-submenu\"><a href=\"../dir2/\"></a></li>" +
+                 "<li class=\"webgen-menu-submenu\"><a href=\"../dir3/\"></a></li></ul></div>", output)
+
+    output = @obj.call('menu', '', Webgen::ContentProcessor::Context.new(:chain => [nodes[:index11_en]]))
+    assert_equal("<div class=\"webgen-menu\">" +
+                 "<ul><li class=\"webgen-menu-submenu webgen-menu-submenu-inhierarchy\"><a href=\"../\"></a>" +
+                 "<ul><li class=\"webgen-menu-submenu webgen-menu-submenu-inhierarchy\"><a href=\"index.en.html\"></a>" +
+                 "<ul><li ><a href=\"file111.en.html\"></a></li>" +
+                 "<li class=\"webgen-menu-item-selected\"><span></span></li></ul></li>" +
+                 "<li ><a href=\"../file11.en.html\"></a></li></ul></li>" +
+                 "<li class=\"webgen-menu-submenu\"><a href=\"../../dir2/\"></a></li>" +
+                 "<li class=\"webgen-menu-submenu\"><a href=\"../../dir3/\"></a></li></ul></div>", output)
+
+
+    @obj.set_params('tag.menu.used_nodes' => 'fragments')
+    output = @obj.call('menu', '', Webgen::ContentProcessor::Context.new(:chain => [nodes[:file11_en]]))
+    @obj.set_params({})
+    assert_equal("<div class=\"webgen-menu\">" +
+                 "<ul><li class=\"webgen-menu-submenu\"><a href=\"#f1\"></a></li>" +
+                 "<li ><a href=\"#f2\"></a></li></ul></div>", output)
+
+    @obj.set_params('tag.menu.start_level' => 5)
+    output = @obj.call('menu', '', Webgen::ContentProcessor::Context.new(:chain => [nodes[:file11_en]]))
+    @obj.set_params({})
+    assert_equal("", output)
+
+    nodes.each {|k,v| v.dirty = false}
+    @website.blackboard.dispatch_msg(:node_changed?, nodes[:file11_en])
+    assert(!nodes[:file11_en].dirty)
+
+    nodes[:index11_en].dirty = true
+    @website.blackboard.dispatch_msg(:node_changed?, nodes[:file11_en])
+    assert(nodes[:file11_en].dirty)
+
+    nodes.each {|k,v| v.dirty = false}
+    nodes[:file11_en_f2]['in_menu'] = false
+    @website.blackboard.dispatch_msg(:node_changed?, nodes[:file11_en])
+    assert(nodes[:file11_en].dirty)
+  end
+
+  def test_menu_tree_for_lang_and_create_menu_tree
+    nodes = create_default_nodes
+
+    tree_en = @obj.send(:menu_tree_for_lang, 'en', nodes[:root])
+    expected = [nodes[:dir1], nodes[:dir11], nodes[:file111_en], nodes[:index11_en],
+                nodes[:file11_en], nodes[:file11_en_f1], nodes[:file11_en_f11], nodes[:file11_en_f2],
+                nodes[:dir2], nodes[:file21_en],
+                nodes[:dir3], nodes[:file31_en], nodes[:file31_en_f1]].collect {|n| n.absolute_lcn}
+
+    assert_equal(expected, tree_en.to_lcn_list.flatten)
+
+    tree_de = @obj.send(:menu_tree_for_lang, 'de', nodes[:root])
+    expected = [nodes[:dir1], nodes[:dir11], nodes[:file111_de], nodes[:file1_de]].collect {|n| n.absolute_lcn}
+
+    assert_equal(expected, tree_de.to_lcn_list.flatten)
+  end
+
+  def test_specific_menu_tree_for_and_build_specific_menu_tree
+    nodes = create_default_nodes
+
+    # testing min_levels and max_levels
+    output = build_menu(nodes[:index_en], [1, 1, 1, true])
+    expected = [nodes[:dir1], nodes[:dir2], nodes[:dir3]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:index_en], [1, 2, 1, true])
+    expected = [nodes[:dir1], nodes[:dir2], nodes[:dir3]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:index_en], [1, 2, 2, true])
+    expected = [nodes[:dir1], nodes[:dir11], nodes[:file11_en], nodes[:dir2], nodes[:file21_en],
+                nodes[:dir3], nodes[:file31_en]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    # testing show_current_subtree_only
+    output = build_menu(nodes[:file11_en], [1, 1, 2, true])
+    expected = [nodes[:dir1], nodes[:dir11], nodes[:file11_en], nodes[:dir2], nodes[:dir3]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:file11_en], [1, 1, 2, false])
+    expected = [nodes[:dir1], nodes[:dir11], nodes[:file11_en], nodes[:dir2], nodes[:file21_en],
+                nodes[:dir3], nodes[:file31_en]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    # testing start_level
+    output = build_menu(nodes[:index_en], [2, 1, 1, true])
+    assert_equal([], output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:file11_en], [2, 1, 2, true])
+    expected = [nodes[:dir11], nodes[:file11_en]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:file11_en], [2, 1, 2, false])
+    expected = [nodes[:dir11], nodes[:file11_en]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:file11_en], [2, 2, 2, false])
+    expected = [nodes[:dir11], nodes[:file111_en], nodes[:index11_en],
+                nodes[:file11_en], nodes[:file11_en_f1], nodes[:file11_en_f2]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:file111_en], [2, 1, 2, true])
+    expected = [nodes[:dir11], nodes[:file111_en], nodes[:index11_en], nodes[:file11_en]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    # testing used_nodes=files setting
+    output = build_menu(nodes[:file11_en], [2, 2, 2, false, 'files'])
+    expected = [nodes[:dir11], nodes[:file111_en], nodes[:index11_en], nodes[:file11_en]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:file11_en], [1, 1, 1, true, 'files'])
+    expected = [nodes[:dir1], nodes[:dir2]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    # testing used_nodes=fragments setting
+    output = build_menu(nodes[:file11_en], [1, 1, 2, false, 'fragments'])
+    expected = [nodes[:file11_en_f1], nodes[:file11_en_f2]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+
+    output = build_menu(nodes[:file11_en], [1, 2, 2, false, 'fragments'])
+    expected = [nodes[:file11_en_f1], nodes[:file11_en_f11], nodes[:file11_en_f2]].collect {|n| n.absolute_lcn}
+    assert_equal(expected, output.to_lcn_list.flatten)
+  end
+
+  def test_create_output_and_menu_item_details
+    nodes = create_default_nodes
+    tree = build_menu(nodes[:file111_en], [1, 2, 3, true])
+    context = Webgen::ContentProcessor::Context.new(:chain => [nodes[:file111_en]])
+    assert_equal("<ul><li class=\"webgen-menu-submenu webgen-menu-submenu-inhierarchy\"><a href=\"../\"></a>" +
+                 "<ul><li class=\"webgen-menu-submenu webgen-menu-submenu-inhierarchy\"><a href=\"index.en.html\"></a>" +
+                 "<ul><li class=\"webgen-menu-item-selected\"><span></span></li><li ><a href=\"index.en.html\"></a></li></ul></li>" +
+                 "<li ><a href=\"../file11.en.html\"></a></li></ul></li>" +
+                 "<li class=\"webgen-menu-submenu\"><a href=\"../../dir2/\"></a>" +
+                 "<ul><li ><a href=\"../../dir2/file21.en.html\"></a></li></ul></li>" +
+                 "<li class=\"webgen-menu-submenu\"><a href=\"../../dir3/\"></a>" +
+                 "<ul><li ><a href=\"../../dir3/file31.en.html\"></a></li></ul></li></ul>", @obj.send(:create_output, context, tree))
+  end
+
+end

data/test/test_tag_metainfo.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/tag/metainfo'
+
+class TestTagMetainfo < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::Tag::Metainfo.new
+    node = Webgen::Node.new(Webgen::Tree.new.dummy_root, 'hallo.page', 'hallo.page', 'test' => 10, 'lang' => 'en')
+    c = Webgen::ContentProcessor::Context.new(:chain => [node])
+    assert_equal('', @obj.call('invalid', '', c))
+    assert_equal('10', @obj.call('test', '', c))
+    assert_equal('en', @obj.call('lang', '', c))
+  end
+
+end

data/test/test_tag_relocatable.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/tag/relocatable'
+
+class TestTagRelocatable < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Tag::Relocatable.new
+  end
+
+  def call(context)
+    @obj.call('relocatable', '', context)
+  end
+
+  def test_call
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, '/file.html', 'file.html', {'lang' => 'en'})
+    dir = Webgen::Node.new(root, '/dir/', 'dir/', 'index_path' => "index.html")
+    file = Webgen::Node.new(dir, '/dir/file.html', 'file.html', {'lang' => 'en'})
+    Webgen::Node.new(dir, '/dir/other.de.html', 'other.html', {'lang' => 'de'})
+    Webgen::Node.new(file, '/dir/file.html#fragment', '#fragment')
+    dir2 = Webgen::Node.new(root, '/dir2/', 'dir2/', 'index_path' => "index.html")
+    Webgen::Node.new(dir2, '/dir2/index.html', 'index.html')
+
+    context = Webgen::ContentProcessor::Context.new(:chain => [node])
+
+    # basic node resolving
+    @obj.set_params('tag.relocatable.path' => 'dir/file.html')
+    assert_equal('dir/file.html', call(context))
+    @obj.set_params('tag.relocatable.path' => 'dir/other.html')
+    assert_equal('', call(context))
+
+    # non-existing fragments
+    @obj.set_params('tag.relocatable.path' => 'file.html#hallo')
+    assert_equal('', call(context))
+
+    # absolute paths
+    @obj.set_params('tag.relocatable.path' => 'http://test.com')
+    assert_equal('http://test.com', call(context))
+
+    # directory paths
+    @obj.set_params('tag.relocatable.path' => 'dir')
+    assert_equal('dir/', call(context))
+    @obj.set_params('tag.relocatable.path' => 'dir2')
+    assert_equal('dir2/index.html', call(context))
+
+    # invalid paths
+    @obj.set_params('tag.relocatable.path' => ':/asdf=-)')
+    assert_equal('', call(context))
+  end
+
+end

data/test/test_tree.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+
+class TestTree < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @tree = Webgen::Tree.new
+  end
+
+  def test_initialize
+    assert_not_nil(@tree.dummy_root)
+  end
+
+  def test_root
+    root = Webgen::Node.new(@tree.dummy_root, '/', '/')
+    assert_equal(root, @tree.root)
+  end
+
+  def test_register_node
+    # Tree#register_node is called when creating a node
+    node = Webgen::Node.new(@tree.dummy_root, 'dummy/', 'dummy')
+    assert_equal(node, @tree['/dummy', :alcn])
+    assert_equal(node, @tree['/dummy', :acn])
+    assert_equal(node, @tree['dummy/', :path])
+    assert_raise(RuntimeError) { Webgen::Node.new(@tree.dummy_root, '/', 'dummy') }
+    assert_raise(RuntimeError) { Webgen::Node.new(@tree.dummy_root, 'dummy/', 'other') }
+    assert_nothing_raised { Webgen::Node.new(@tree.dummy_root, 'dummy/', 'unknown', {'no_output' => true}) }
+  end
+
+  def test_delete_node
+    nrcalls = 0
+    @website.blackboard.add_listener(:before_node_deleted) { nrcalls += 1 }
+
+    root = Webgen::Node.new(@tree.dummy_root, '/', '/')
+    file = Webgen::Node.new(root, 'testfile', 'testfile')
+    dir = Webgen::Node.new(root, 'testdir/', 'testdir')
+
+    @tree.delete_node(@tree.dummy_root)
+    assert_not_nil(@tree[''])
+
+    @tree.delete_node(root)
+    assert_not_nil(@tree['/'])
+
+    @tree.delete_node(file)
+    assert_nil(@tree['/testfile'])
+    assert_nil(@tree['/testfile', :acn])
+    assert_nil(@tree.node_info['/testfile'])
+    assert_equal(1, root.children.size)
+    assert_equal(1, nrcalls)
+
+    @tree.delete_node('/', true)
+    assert_nil(@tree['/testdir'])
+    assert_nil(@tree['/testdir', :acn])
+    assert_nil(@tree.node_info['/testdir'])
+    assert_nil(@tree['/'])
+    assert_nil(@tree.node_info['/'])
+    assert_equal(3, nrcalls)
+
+    Webgen::Node.new(root, 'testfile', 'testfile')
+    Webgen::Node.new(root, 'testdir/', 'testdir')
+    @tree.delete_node(root, true)
+    assert_equal([@tree.dummy_root], @tree.node_access[:alcn].values)
+  end
+
+end

data/test/test_website.rb

@@ -0,0 +1,96 @@
+require 'test/unit'
+require 'webgen/website'
+require 'tmpdir'
+require 'fileutils'
+
+class TestWebsite < Test::Unit::TestCase
+
+  def test_initialize
+    ws = Webgen::Website.new('dir') do
+      assert_equal(ws, Webgen::WebsiteAccess.website)
+      throw :called
+    end
+    assert_nil(ws.blackboard)
+    assert_nil(ws.cache)
+    assert_nil(ws.config)
+    assert_nil(ws.tree)
+    assert_equal('dir', ws.directory)
+    assert_throws(:called) { ws.init }
+    assert_nil(Thread.current[:webgen_website])
+  end
+
+  def test_autoload_service
+    ws = Webgen::Website.new('unknown', nil)
+    ws.init
+    ws.instance_eval { @cache = Webgen::Cache.new }
+    ws.autoload_service('[]', 'Hash')
+    assert_equal([], ws.cache.permanent[:classes])
+    ws.blackboard.invoke('[]', 5)
+    assert_equal(['Hash'], ws.cache.permanent[:classes])
+  end
+
+  def test_init
+    ws = Webgen::Website.new('hallo')
+    ws.init
+    assert_not_nil(ws.config)
+    assert_not_nil(ws.blackboard)
+    assert_not_nil(ws.cache)
+    assert_not_nil(ws.tree)
+  end
+
+  def test_render
+    ws = Webgen::Website.new(File.dirname(__FILE__), nil) do |config|
+      config['website.cache'] = [:string, '']
+    end
+    ws.render
+    assert(ws.config['website.cache'][1].length > 0)
+  end
+
+  def test_execute_in_env
+    ws = Webgen::Website.new('hallo')
+    assert_nil(Webgen::WebsiteAccess.website)
+    ws.execute_in_env { assert_not_nil(Webgen::WebsiteAccess.website) }
+  end
+
+  def test_read_config_file
+    dir = File.join(Dir.tmpdir, 'webgen-' + Process.pid.to_s)
+    FileUtils.mkdir_p(dir)
+
+    ws = Webgen::Website.new(dir)
+    ws.init
+    assert_equal('', ws.logger.log_output)
+    FileUtils.touch(File.join(dir, 'config.yml'))
+    ws.init
+    assert_match(/spelling error/, ws.logger.log_output)
+
+    File.open(File.join(dir, 'config.yaml'), 'w+') {|f| f.write('- unknown')}
+    assert_raise(Webgen::Website::ConfigFileInvalid) { ws.init }
+
+    File.open(File.join(dir, 'config.yaml'), 'w+') {|f| f.write('webgen.unknown: doit')}
+    assert_raise(Webgen::Website::ConfigFileInvalid) { ws.init }
+
+    File.open(File.join(dir, 'config.yaml'), 'w+') {|f| f.write("website.lang: de\ndefault_meta_info: {:all: {hallo: du}}")}
+    ws.init
+    assert_equal('de', ws.config['website.lang'])
+    assert_equal('du', ws.config['sourcehandler.default_meta_info'][:all]['hallo'])
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+  def test_clean
+    dir = File.join(Dir.tmpdir, 'webgen-' + Process.pid.to_s)
+    FileUtils.mkdir_p(dir)
+    FileUtils.mkdir_p(File.join(dir, 'src'))
+    FileUtils.touch(File.join(dir, 'src', 'test.jpg'))
+
+    ws = Webgen::Website.new(dir, nil)
+    ws.render
+    assert(File.exists?(File.join(dir, 'out', 'test.jpg')))
+    ws.clean
+    assert(!File.exists?(File.join(dir, 'out', 'test.jpg')))
+    assert(File.directory?(File.join(dir, 'out')))
+    ws.clean(true)
+    assert(!File.directory?(File.join(dir, 'out')))
+  end
+
+end