webgen 0.4.7 → 0.5.0

data/test/unittests/tc_filehandler_page.rb

@@ -1,183 +0,0 @@
-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_sipttra.rb

@@ -1,26 +0,0 @@
-require 'webgen/test'
-
-class SipttraHandlerTest < Webgen::PluginTestCase
-
-  plugin_files [
-    'webgen/plugins/filehandlers/sipttra.rb',
-    'webgen/plugins/filehandlers/directory.rb'
-  ]
-  plugin_to_test 'File/SipttraHandler'
-
-  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, 'test.todo' ) )
-    node = @manager['Core/FileHandler'].create_node( File.basename( file ), root, @plugin )
-
-    assert_not_nil( node )
-    assert_equal( 'test.html', node.path )
-    assert_equal( file, node.node_info[:src] )
-    assert_kind_of( Sipttra::Tracker, node.node_info[:sipttra] )
-  end
-
-end

data/test/unittests/tc_filehandler_template.rb

@@ -1,64 +0,0 @@
-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 = @manager['Core/FileHandler'].create_node( File.basename( file ), root, @plugin )
-
-    assert_not_nil( node )
-    assert_equal( true, node['useERB'] )
-    assert_equal( ['content', 'html'], node['blocks'][0] )
-    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( 'index.de.page' )
-    assert_equal( [], @manager['File/TemplateHandler'].templates_for_node( test_t ) )
-
-    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

@@ -1,12 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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