gettalong-webgen 0.5.4.20080929

data/test/test_sourcehandler_page.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/sourcehandler/page'
+require 'stringio'
+
+class TestSourceHandlerPage < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @website.blackboard.del_service(:templates_for_node)
+    @website.blackboard.del_service(:parse_html_sections)
+    @website.blackboard.del_service(:create_fragment_nodes)
+    @website.blackboard.add_service(:templates_for_node) {|node| []}
+    @website.blackboard.add_service(:parse_html_sections) {[]}
+    @website.blackboard.add_service(:create_fragment_nodes) {nil}
+    @obj = Webgen::SourceHandler::Page.new
+    @root = Webgen::Node.new(Webgen::Tree.new.dummy_root, 'test/', 'test')
+    @path = path_with_meta_info('/index.page') {StringIO.new('content')}
+    @path.meta_info.update({'lang'=>'eo', 'test'=>'yes', 'sort_info'=>6})
+    @website.blackboard.add_service(:source_paths) {{@path.path => @path}}
+  end
+
+  def test_create_node
+    node = @obj.create_node(@root, @path.dup)
+
+    assert_not_nil(node)
+    assert_equal('test/index.eo.html', node.path)
+    assert_equal(@obj.class.name, node.node_info[:processor])
+    assert_equal('Index', node['title'])
+    assert_equal('yes', node['test'])
+    assert_equal(6, node['sort_info'])
+    assert_equal(Webgen::LanguageManager.language_for_code('epo'), node.lang)
+    assert_not_nil(@website.cache.permanent[:page_sections]['/test/index.eo.html'])
+
+    assert_nil(@obj.create_node(@root, @path.dup))
+
+    @root.tree.delete_node(node)
+    path = @path.dup
+    def path.changed?
+      false
+    end
+    @obj.create_node(@root, path)
+  end
+
+  def test_content
+    node = @obj.create_node(@root, @path)
+    assert_equal("content", @obj.content(node))
+  end
+
+  def test_render_node
+    node = @obj.create_node(@root, @path)
+    assert_equal("content", @obj.render_node(node))
+    assert_raise(RuntimeError) { @obj.render_node(node, 'other') }
+  end
+
+  def test_meta_info_changed
+    node = @obj.create_node(@root, @path)
+    @website.blackboard.dispatch_msg(:node_meta_info_changed?, node)
+    assert(node.meta_info_changed?)
+
+    node.dirty_meta_info = false
+    @website.cache.restore(@website.cache.dump)
+    @website.cache[[:sh_page_node_mi, node.absolute_lcn]]['modified_at'] = Time.now
+    @website.blackboard.dispatch_msg(:node_meta_info_changed?, node)
+    assert(!node.meta_info_changed?)
+  end
+
+end

data/test/test_sourcehandler_sitemap.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/sourcehandler'
+require 'stringio'
+
+class TestSourceHandlerSitemap < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  SITEMAP_CONTENT = <<EOF
+---
+site_url: http://example.com
+default_change_freq: daily
+EOF
+
+  def setup
+    super
+    @nodes = create_sitemap_nodes
+    @nodes.each {|k,v| v['modified_at'] = Time.now}
+    @nodes[:file11_en]['priority'] = 0.9
+    @nodes[:file11_en]['change_freq'] = 'hourly'
+    @obj = Webgen::SourceHandler::Sitemap.new
+    @path = path_with_meta_info('/test.sitemap', {}, @obj.class.name) {StringIO.new(SITEMAP_CONTENT)}
+  end
+
+  def test_create_node
+    sitemap = @obj.create_node(@nodes[:root], @path)
+
+    assert_not_nil(sitemap)
+    assert_equal('/test.xml', sitemap.path)
+    assert_equal('/test.xml', sitemap.absolute_lcn)
+
+    assert_raise(RuntimeError) do
+      @obj.create_node(@nodes[:root], path_with_meta_info('/test.sitemap', {}, @obj.class.name) {StringIO.new('')})
+    end
+  end
+
+  def test_content
+    sitemap = @obj.create_node(@nodes[:root], @path)
+    content = sitemap.content
+    assert_match(/<changefreq>daily<\/changefreq>/, content)
+    assert_match(/<changefreq>hourly<\/changefreq>/, content)
+    assert_match(/<priority>0.5<\/priority>/, content)
+    assert_match(/<priority>0.9<\/priority>/, content)
+  end
+
+end

data/test/test_sourcehandler_template.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/node'
+require 'webgen/path'
+require 'webgen/sourcehandler/template'
+require 'stringio'
+
+class TestSourceHandlerTemplate < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::SourceHandler::Template.new
+  end
+
+  def test_create_node
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    node = @obj.create_node(root, path_with_meta_info('/default.template') {StringIO.new('')})
+
+    assert_not_nil(node)
+    assert_not_nil(node.node_info[:page])
+    assert_equal('test/default.template', node.path)
+  end
+
+  def test_templates_for_node
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    default_template = Webgen::Node.new(root, 'default.template', 'default.template')
+    default_de_template = Webgen::Node.new(root, 'default.de.template', 'default.template', {'lang' => 'de'})
+    other_template = Webgen::Node.new(root, 'other.template', 'other.template')
+    stopped_template = Webgen::Node.new(root, 'stopped.html', 'stopped.page', { 'template' => nil})
+    invalid_template = Webgen::Node.new(root, 'invalid.template', 'invalid.template', {'template' => 'invalidity'})
+    chained_template = Webgen::Node.new(root, 'chained.template', 'chained.template', {'template' => 'other.template'})
+    german_file = Webgen::Node.new(root, 'german.html', 'german.page', {'lang' => 'de', 'template' => 'other.template'})
+    dir = Webgen::Node.new(root, '/dir/', 'dir')
+    dir_default_template = Webgen::Node.new(dir, '/dir/default.template', 'default.template')
+
+    assert_equal([], @obj.templates_for_node(default_template))
+    assert_equal([], @obj.templates_for_node(stopped_template))
+    assert_equal([default_template], @obj.templates_for_node(other_template))
+    assert_equal([default_template], @obj.templates_for_node(invalid_template))
+    assert_equal([default_template, other_template], @obj.templates_for_node(chained_template))
+    assert_equal([default_de_template, other_template], @obj.templates_for_node(german_file))
+    assert_equal([default_template], @obj.templates_for_node(dir_default_template))
+
+    @website.cache.reset_volatile_cache
+    root.tree.delete_node(default_template)
+    assert_equal([], @obj.templates_for_node(other_template))
+  end
+
+  def test_default_template
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    dir = Webgen::Node.new(root, 'dir/', 'dir')
+    template = Webgen::Node.new(root, 'default.template', 'default.template')
+
+    assert_equal(template, @obj.default_template(root, nil))
+    assert_equal(template, @obj.default_template(dir, nil))
+    root.tree.delete_node(template)
+    assert_nil(@obj.default_template(root, nil))
+  end
+
+end

data/test/test_sourcehandler_virtual.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/sourcehandler'
+require 'stringio'
+
+class TestSourceHandlerVirtual < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  CONTENT=<<EOF
+\\--- !omap
+- path.de.html:
+
+- /dir/:
+    title: My Dir
+
+- /dir/file.html:
+
+- /directory/path.en.html:
+    url: other.html
+    title: new title
+
+- api.html:
+    url: http://www.example.com
+    title: Absolute
+EOF
+
+  def test_create_node
+    obj = Webgen::SourceHandler::Virtual.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    shm = Webgen::SourceHandler::Main.new # for using service :create_nodes
+    time = Time.now
+    nodes = obj.create_node(root, path_with_meta_info('/virtuals', {'modified_at' => time}, obj.class.name) {StringIO.new(CONTENT)})
+
+    nodes.each {|n| assert_equal('/virtuals', n.node_info[:src])}
+
+    path_de = root.tree['/path.de.html']
+    path_en = root.tree['/directory/path.en.html']
+    dir = root.tree['/dir']
+    assert_not_nil(path_de)
+    assert_not_nil(dir)
+    assert_not_nil(path_en)
+
+    assert_equal('new title', path_en['title'])
+    assert_equal(time, path_en['modified_at'])
+    assert(path_en['no_output'])
+    assert_equal('My Dir', dir['title'])
+    assert_equal('directory/other.html', path_de.route_to(path_en))
+    assert_equal('../path.de.html', dir.route_to(path_de))
+    assert_equal('../directory/other.html', dir.route_to(path_en))
+
+    assert_equal('http://www.example.com', root.tree['/api.html'].path)
+    assert_equal('http://www.example.com', root.tree['/path.de.html'].route_to(root.tree['/api.html']))
+  end
+
+end

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_breadcrumbtrail.rb

@@ -0,0 +1,89 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/tag'
+
+class TestTagBreadcrumbTrail < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Tag::BreadcrumbTrail.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/', {'title' => 'Dir1'}),
+      :dir11 => dir11 = Webgen::Node.new(dir1, '/dir1/dir11/', 'dir11/', {'index_path' => 'index.html'}),
+      :index11_en => Webgen::Node.new(dir11, '/dir1/dir11/index.html', 'index.html',
+                                      {'lang' => 'en', 'routed_title' => 'Dir11', 'title' => 'Index'}),
+      :file11_en => Webgen::Node.new(dir11, '/dir1/dir11/file111.html', 'file111.html',
+                                     {'lang' => 'en', 'title' => 'File111'}),
+      :index_en => Webgen::Node.new(root, '/index.html', 'index.html', {'lang' => 'en'}),
+    }
+  end
+
+  def call(context, separator, omit_index_path, start_level, end_level)
+    @obj.set_params({'tag.breadcrumbtrail.separator' => separator,
+                      'tag.breadcrumbtrail.omit_index_path' => omit_index_path,
+                      'tag.breadcrumbtrail.start_level' => start_level,
+                      'tag.breadcrumbtrail.end_level' => end_level})
+    result = @obj.call('breadcrumbTrail', '', context)
+    @obj.set_params({})
+    result
+  end
+
+  def test_call
+    nodes = create_default_nodes
+    context = Webgen::ContentProcessor::Context.new(:chain => [nodes[:file11_en]])
+
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a> / <a href="index.html">Dir11</a> / <span>File111</span>',
+                 call(context, ' / ', false, 0, -1))
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a> / <a href="index.html">Dir11</a> / <span>File111</span>',
+                 call(context, ' / ', true, 0, -1))
+    assert_equal('<a href="../">Dir1</a> / <a href="index.html">Dir11</a>',
+                 call(context, ' / ', true, 1, -2))
+    assert_equal('<a href="../">Dir1</a> / <a href="index.html">Dir11</a>',
+                 call(context, ' / ', false, 1, -2))
+
+
+    context[:chain] = [nodes[:index11_en]]
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a> / <span>Dir11</span> / <span>Index</span>',
+                 call(context, ' / ', false, 0, -1))
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a> / <span>Dir11</span>',
+                 call(context, ' / ', true, 0, -1))
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a> / <span>Dir11</span>',
+                 call(context, ' / ', false, 0, -2))
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a>',
+                 call(context, ' / ', true, 0, -2))
+
+    assert_equal('<a href="../../index.html"></a> | <a href="../">Dir1</a> | <span>Dir11</span> | <span>Index</span>',
+                 call(context, ' | ', false, 0, -1))
+
+
+    nodes[:index11_en]['omit_index_path'] = false
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a> / <span>Dir11</span> / <span>Index</span>',
+                 call(context, ' / ', true, 0, -1))
+    nodes[:index11_en]['omit_index_path'] = true
+    assert_equal('<a href="../../index.html"></a> / <a href="../">Dir1</a> / <span>Dir11</span>',
+                 call(context, ' / ', false, 0, -1))
+  end
+
+  def test_node_changed
+    nodes = create_default_nodes
+    context = Webgen::ContentProcessor::Context.new(:chain => [nodes[:file11_en]])
+    call(context, ' / ', false, 0, -1)
+
+    nodes[:file11_en].dirty = false
+    @website.blackboard.dispatch_msg(:node_changed?, nodes[:file11_en])
+    assert(!nodes[:file11_en].dirty)
+
+    nodes[:index11_en].dirty_meta_info = true
+    @website.blackboard.dispatch_msg(:node_changed?, nodes[:file11_en])
+    assert(nodes[:file11_en].dirty)
+  end
+
+end

data/test/test_tag_coderay.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/tag'
+
+class TestTagCoderay < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Tag::Coderay.new
+  end
+
+  def call(context, body, lang, process)
+    @obj.set_params({'tag.coderay.lang' => lang,
+                      'tag.coderay.process' => process})
+    result = @obj.call('coderay', body, context)
+    @obj.set_params({})
+    result
+  end
+
+  def test_call
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/', {'title' => 'Hallo'})
+    context = Webgen::ContentProcessor::Context.new(:chain => [root])
+
+    assert(call(context, 'TestData', 'html', false).include?('TestData'))
+    assert(call(context, '{title:}', :ruby, true).include?('Hallo'))
+  end
+
+end

data/test/test_tag_date.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/contentprocessor'
+require 'webgen/tag'
+require 'time'
+
+class TestTagDate < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def test_call
+    @obj = Webgen::Tag::Date.new
+    assert_not_nil(Time.parse(@obj.call('date', '', Webgen::ContentProcessor::Context.new)))
+  end
+
+end