webgen 0.3.8 → 0.4.0

data/test/unittests/tc_filehandler_page.rb

@@ -0,0 +1,183 @@
+require 'yaml'
+require 'webgen/test'
+
+class FragmentNodeTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/page.rb',
+  ]
+
+  def test_accessors
+    @node = @wrapper::FileHandlers::PageHandler::FragmentNode.new( nil, 'test' )
+    assert_same( @node, @node.node_info[:processor] )
+    assert( !@node.meta_info['inMenu'] )
+  end
+
+end
+
+
+class PageNodeTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/page.rb',
+  ]
+
+  def setup
+    super
+    @testdata = YAML::load( File.read( fixture_path( 'testdata.yaml' ) ) )
+    @data = WebPageData.new( @testdata['data'], 'default'=>proc{|c| c} )
+    @node = @wrapper::FileHandlers::PageHandler::PageNode.new( nil, 'test.html', @data )
+  end
+
+  def test_initialization
+    assert_same( @data, @node.node_info[:pagedata] )
+    @testdata['sections'].each do |name|
+      assert_not_nil( @node.resolve_node( name ) )
+    end
+  end
+
+  def test_match
+    @node.node_info[:local_pagename] = 'test.de.page'
+    @node.node_info[:pagename] = 'test.page'
+    assert( @node =~ 'test.de.page' )
+    assert( @node =~ 'test.de.page#something' )
+    assert( @node =~ 'test.page' )
+    assert( @node =~ 'test.page#something' )
+    assert( @node =~ 'test.html' )
+    assert( @node =~ 'test.html#something' )
+  end
+
+end
+
+
+class PageHandlerTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/directory.rb',
+    'webgen/plugins/filehandlers/template.rb',
+    'webgen/plugins/filehandlers/page.rb',
+    'webgen/plugins/tags/tag_processor.rb',
+    'webgen/plugins/tags/block.rb',
+    'webgen/plugins/tags/meta.rb',
+  ]
+  plugin_to_test 'File/PageHandler'
+
+
+  def test_initialization
+    assert_not_nil( @plugin )
+  end
+
+  def test_create_node_from_data
+    root = @manager['Core/FileHandler'].instance_eval { create_root_node }
+    testdata = YAML::load( File.read( fixture_path( 'testdata.yaml' ) ) )
+    node = @plugin.create_node_from_data( 'index.page', root, testdata['data'], {'lang'=>'eo', 'test'=>'yes', 'orderInfo'=>6} )
+
+    assert_equal( 'index.eo.html', node.path )
+    assert_equal( 'index.page', node.node_info[:pagename] )
+    assert_equal( 'index.eo.page', node.node_info[:local_pagename] )
+    assert_equal( 'index.page', node.node_info[:src] )
+    assert_equal( @plugin, node.node_info[:processor] )
+    assert_equal( 'Index', node['title'] )
+    assert_equal( 'yes', node['test'] )
+    assert_equal( 6, node['orderInfo'] )
+    assert_equal( Webgen::LanguageManager.language_for_code( 'epo' ), node['lang'] )
+
+    node1 = @plugin.create_node_from_data( 'index.page', root, testdata['data'], {'lang'=>'eo'} )
+    assert_same( node, node1 )
+  end
+
+  def test_render_node
+    root = @manager['Core/FileHandler'].instance_eval { build_tree }
+    file2 = root.resolve_node( 'file2.de.page' )
+
+    assert_equal( "Template\n"+
+                  "Block 1 is inMenu true\n"+
+                  "Template", @plugin.render_node( file2 ) )
+    assert_equal( "", @plugin.render_node( file2, 'other' ) )
+    assert_equal( "Block 2 is inMenu true", @plugin.render_node( file2, 'other', false ) )
+  end
+
+  def test_node_for_lang
+    root = @manager['Core/FileHandler'].instance_eval { build_tree }
+
+    index = root.resolve_node( 'index.page' )
+    de = Webgen::LanguageManager.language_for_code( 'de' )
+    en = Webgen::LanguageManager.language_for_code( 'en' )
+    eo = Webgen::LanguageManager.language_for_code( 'eo' )
+
+    assert_equal( root.resolve_node( 'index.de.page' ), @plugin.node_for_lang( index, de ) )
+    assert_equal( root.resolve_node( 'index.en.page' ), @plugin.node_for_lang( index, en ) )
+    assert_nil( @plugin.node_for_lang( index, eo ) )
+  end
+
+  def test_link_from
+    root = @manager['Core/FileHandler'].instance_eval { build_tree }
+    index_en = root.resolve_node( 'index.en.page' )
+    index_de = root.resolve_node( 'index.de.page' )
+    file1 = root.resolve_node( 'file1.page' )
+
+    assert_equal( '<a href="index.html">Index</a>', @plugin.link_from( index_de, file1 ) )
+    assert_equal( 'File1', @plugin.link_from( file1, index_de ) )
+  end
+
+  def test_analyse_file_name
+    analyse_file_name( OpenStruct.new( {'lang' => @manager.param_for_plugin( 'Core/Configuration', 'lang' ),
+                                        'filename' => 'default.page',
+                                        'name' => 'default', 'orderInfo' => 0,
+                                        'title' => 'Default', 'useLangPart' => false } ), nil )
+    analyse_file_name( OpenStruct.new( {'lang' => 'de',
+                                        'filename' => 'default.page',
+                                        'name' => 'default', 'orderInfo' => 0,
+                                        'title' => 'Default', 'useLangPart' => true } ), 'de' )
+    analyse_file_name( OpenStruct.new( {'lang' => 'de',
+                                        'filename' => 'default.de.page',
+                                        'name' => 'default', 'orderInfo' => 0,
+                                        'title' => 'Default', 'useLangPart' => true } ), nil )
+    analyse_file_name( OpenStruct.new( {'lang' => 'en',
+                                        'filename' => 'default.de.page',
+                                        'name' => 'default', 'orderInfo' => 0,
+                                        'title' => 'Default', 'useLangPart' => false } ), 'en' )
+    analyse_file_name( OpenStruct.new( {'lang' => 'eo',
+                                        'filename' => '12.Hello webpage_hello.eo.page',
+                                        'name' => 'Hello webpage_hello', 'orderInfo' => 12,
+                                        'title' => 'Hello webpage hello', 'useLangPart' => true } ), nil )
+    analyse_file_name( OpenStruct.new( {'lang' => @manager.param_for_plugin( 'Core/Configuration', 'lang' ),
+                                        'filename' => 'default.e.page',
+                                        'name' => 'default', 'orderInfo' => 0,
+                                        'title' => 'Default', 'useLangPart' => false } ), nil )
+    analyse_file_name( OpenStruct.new( {'lang' => @manager.param_for_plugin( 'Core/Configuration', 'lang' ),
+                                        'filename' => 'default.eadd.page',
+                                        'name' => 'default', 'orderInfo' => 0,
+                                        'title' => 'Default', 'useLangPart' => false } ), nil )
+    analyse_file_name( OpenStruct.new( {'lang' => @manager.param_for_plugin( 'Core/Configuration', 'lang' ),
+                                        'filename' => 'blabla.default.eadd.page',
+                                        'name' => 'blabla', 'orderInfo' => 0,
+                                        'title' => 'Blabla', 'useLangPart' => false } ), nil )
+  end
+
+  def test_create_output_name
+    style = [:name, ['.', :lang], 545, '.html']
+    check_output_name( 'index.de.html', 'index.de.page', style )
+    check_output_name( 'index.html', 'index.de.page', style, true )
+    check_output_name( 'index.html', 'index.en.page', style )
+
+    style = [:name, '.', :lang, '.html']
+    check_output_name( 'index.de.html', 'index.de.page', style )
+    check_output_name( 'index..html', 'index.de.page', style, true )
+    check_output_name( 'index..html', 'index.en.page', style )
+  end
+
+  #######
+  private
+  #######
+
+  def check_output_name( expected, given, style, omitLang = false )
+    analysed = @plugin.instance_eval { analyse_file_name( given ) }
+    assert_equal( expected, @plugin.instance_eval { create_output_name( analysed, style, omitLang ) })
+  end
+
+  def analyse_file_name( struct, lang )
+    assert_equal( struct, @plugin.instance_eval { analyse_file_name( struct.filename, lang ) })
+  end
+
+end

data/test/unittests/tc_filehandler_template.rb

@@ -0,0 +1,60 @@
+require 'webgen/test'
+
+class TemplateFileHandlerTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/template.rb',
+    'webgen/plugins/filehandlers/directory.rb'
+  ]
+  plugin_to_test 'File/TemplateHandler'
+
+  def test_initialization
+    assert_not_nil( @plugin )
+  end
+
+  def test_create_node
+    root = @manager['Core/FileHandler'].instance_eval { create_root_node }
+    file = sample_site( File.join( Webgen::SRC_DIR, 'default.template' ) )
+    node = @plugin.create_node( file, root, {} )
+
+    assert_not_nil( node )
+    assert_equal( true, node['useERB'] )
+    assert_equal( File.basename( file ), node.path )
+    assert_equal( file, node.node_info[:src] )
+    assert_equal( File.basename( file ), node.node_info[:pagename] )
+    assert_equal( File.basename( file ), node.node_info[:local_pagename] )
+    assert_equal( @plugin, node.node_info[:processor] )
+  end
+
+  def test_templates_for_node
+    root = @manager['Core/FileHandler'].instance_eval { build_tree }
+
+    default_t = root.resolve_node( 'default.template' )
+    assert_equal( [], default_t.templates_for_node )
+
+    test_t = root.resolve_node( 'test.template' )
+    assert_equal( [default_t], test_t.templates_for_node )
+
+    root.del_child( default_t )
+    assert_equal( [default_t], test_t.templates_for_node )
+    root.add_child( default_t )
+
+    invalid_t = root.resolve_node( 'invalid.template' )
+    assert_equal( [default_t], invalid_t.templates_for_node )
+
+    chained_t = root.resolve_node( 'chained.template' )
+    assert_equal( [default_t, test_t], chained_t.templates_for_node )
+  end
+
+  def test_get_default_template
+    root = Node.new( nil, '/' )
+    template = Node.new( root, 'default.template' )
+    dir1 = Node.new( root, 'dir1/' )
+
+    assert_equal( template, @plugin.instance_eval { get_default_template( root, 'default.template' ) })
+    assert_equal( template, @plugin.instance_eval { get_default_template( dir1, 'default.template' ) })
+    root.del_child( template )
+    assert_nil( @plugin.instance_eval { get_default_template( root, 'default.template' ) })
+  end
+
+end

data/test/unittests/tc_htmlvalidators_default.rb

@@ -0,0 +1,12 @@
+require 'webgen/test'
+
+class DefaultHtmlValidatorTest < Webgen::PluginTestCase
+
+  plugin_files ['webgen/plugins/htmlvalidators/default.rb']
+
+  def test_validate_file
+    plugin = @wrapper::HtmlValidators::DefaultHtmlValidator.new( @manager )
+    assert_raises( NotImplementedError ) { plugin.validate_file( '' ) }
+  end
+
+end

data/test/unittests/tc_htmlvalidators_xmllint.rb

@@ -0,0 +1,19 @@
+require 'webgen/test'
+
+class XmllintHtmlValidatorTest < Webgen::PluginTestCase
+
+  plugin_files ['webgen/plugins/htmlvalidators/xmllint.rb']
+  plugin_to_test 'HtmlValidator/xmllint'
+
+
+  def test_loading_of_plugin
+    assert_not_nil( @plugin )
+  end
+
+  def test_validate_file
+    assert_nothing_raised do
+      assert( !@plugin.validate_file( 'invalid' ) )
+    end
+  end
+
+end

data/test/unittests/tc_languages.rb

@@ -0,0 +1,57 @@
+require 'webgen/test'
+require 'webgen/languages'
+
+class LanguageTest < Webgen::TestCase
+
+  def test_get_language
+    assert_nil( Webgen::LanguageManager.language_for_code( nil ) )
+
+    lang1 = lang2 = lang3 = lang4 = nil
+    assert_nothing_raised do
+      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' )
+    end
+    [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_nothing_raised do
+      assert_equal( 'de', de )
+      assert_equal( de, 'de' )
+      assert_equal( "de", de.to_s )
+      assert_equal( "Implicitly de", "Implicitly " + de )
+    end
+    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/unittests/tc_listener.rb

@@ -0,0 +1,72 @@
+require 'webgen/test'
+require 'webgen/listener'
+
+
+class ListenerTest < Webgen::TestCase
+
+  class ListenerTestclass
+    include Listener
+
+    def add_msg
+      add_msg_name :testmsg
+    end
+
+    def del_msg
+      del_msg_name :testmsg
+    end
+
+    def dispatch( msgname, args )
+      dispatch_msg( msgname, args )
+    end
+  end
+
+
+  def setup
+    @testclass = ListenerTestclass.new
+  end
+
+
+  def test_message_handling
+    assert_kind_of( Listener, @testclass )
+    assert_nothing_raised do
+      @testclass.del_msg
+      @testclass.add_msg
+      @testclass.add_msg
+      @testclass.del_msg
+    end
+  end
+
+
+  def msg_receiver( *args )
+    @times += 1
+    assert_equal( 1, args.length )
+  end
+
+
+  def test_message_passing
+    assert_nothing_raised { @testclass.add_msg_listener( :testmsg, "hello" ) }
+    assert_nothing_raised { @testclass.del_msg_listener( :testmsg, "hello" ) }
+
+    @testclass.add_msg
+
+    assert_raise( NoMethodError ) { @testclass.add_msg_listener( :testmsg, "hello" ) }
+    assert_raise( RuntimeError ) { @testclass.add_msg_listener( :testmsg ) }
+
+    @times = 0
+    assert_nothing_raised do
+      @testclass.add_msg_listener( :testmsg, method(:msg_receiver) )
+      @testclass.add_msg_listener( :testmsg ) do |*args|
+        msg_receiver( *args )
+      end
+    end
+    assert_equal( 0, @times )
+
+    @testclass.dispatch( :testmsg, 'hello' )
+    assert_equal( 2, @times, 'some receiver objects were not called'  )
+
+    assert_nothing_raised { @testclass.del_msg_listener( :testmsg, method( :msg_receiver ) ) }
+    @testclass.dispatch( :testmsg, 'hello' )
+    assert_equal( 3, @times  )
+  end
+
+end

data/test/unittests/tc_menustyles_default.rb

@@ -0,0 +1,51 @@
+require 'webgen/test'
+
+class DefaultMenuStyleTest < Webgen::PluginTestCase
+
+  plugin_files [
+                'webgen/plugins/menustyles/default.rb',
+                'webgen/plugins/filehandlers/directory.rb',
+                'webgen/plugins/filehandlers/page.rb',
+                fixture_path( 'menustyle.rb' )
+               ]
+
+  plugin_to_test 'MenuStyle/Default'
+
+  def test_options_hash
+    plugin = @manager['MenuStyle/Test']
+
+    assert_equal( @manager['MenuStyle/Default'].param( 'divClass' ), plugin.param( 'divClass' ) )
+    assert_equal( 'testvalue', plugin.param( 'testparam' ) )
+
+    plugin.instance_eval { @options = {'divClass' => 'none', 'testparam' => 'other'} }
+    assert_equal( 'none', plugin.param( 'divClass' ) )
+    assert_equal( 'other', plugin.param( 'testparam' ) )
+
+    assert_raises( Webgen::PluginParamNotFound ) { plugin.param( 'invalidParam' ) }
+  end
+
+  def test_menu_item_details
+    root = @manager['Core/FileHandler'].instance_eval { build_tree }
+
+    src_node = root.resolve_node( 'dir1/dir11/file111.en.page' )
+    csub  = @plugin.param( 'submenuClass' )
+    chier = @plugin.param( 'submenuInHierarchyClass' )
+    csel  = @plugin.param( 'selectedMenuitemClass' )
+
+    assert_equal( ["class=\"#{csub} #{chier}\"", root.link_from( src_node )],
+                  @plugin.instance_eval { menu_item_details( src_node, root ) } )
+
+    node = root.resolve_node( 'file1.en.page' )
+    assert_equal( [nil, node.link_from( src_node )],
+                  @plugin.instance_eval { menu_item_details( src_node, node ) } )
+
+    node = root.resolve_node( 'dir1' )
+    assert_equal( ["class=\"#{csub} #{chier}\"", node.link_from( src_node )],
+                  @plugin.instance_eval { menu_item_details( src_node, node ) } )
+
+    node = root.resolve_node( 'dir1/dir11/file111.en.page' )
+    assert_equal( ["class=\"#{csel}\"", node.link_from( src_node )],
+                  @plugin.instance_eval { menu_item_details( src_node, node ) } )
+  end
+
+end