webgen 0.3.8 → 0.4.0

data/test/unittests/tc_filehandler_directory.rb

@@ -0,0 +1,134 @@
+require 'fileutils'
+require 'webgen/test'
+
+class DirNodeTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/directory.rb'
+  ]
+
+  def test_accessors
+    dir = @wrapper::FileHandlers::DirectoryHandler::DirNode.new( nil, 'dir/', {'test'=>'test'} )
+    assert_equal( 'Dir', dir['title'] )
+    assert_equal( 'test', dir['test'] )
+  end
+
+  def test_order_info
+    dir = @wrapper::FileHandlers::DirectoryHandler::DirNode.new( nil, 'dir/' )
+    dir.node_info[:processor] = @manager['File/DirectoryHandler']
+
+    assert_equal( 0, dir.order_info )
+
+    index = Node.new( dir, 'index.page' )
+    dir.meta_info.delete( 'indexFile' )
+    assert_equal( 0, dir.order_info )
+
+    dir['indexFile'] = 'index.page'
+    index['orderInfo'] = 1
+    assert_equal( 0, dir.order_info )
+
+    dir['orderInfo'] = 2
+    assert_equal( 2, dir.order_info )
+  end
+
+  def test_index_file
+    dir = @wrapper::FileHandlers::DirectoryHandler::DirNode.new( nil, 'dir/' )
+    dir.node_info[:processor] = @manager['File/DirectoryHandler']
+
+    assert_nil( dir['indexFile'] )
+
+    index = Node.new( dir, 'index.page' )
+
+    dir['indexFile'] = index
+    assert_equal( index, dir['indexFile'] )
+
+    dir['indexFile'] = 'index.page'
+    assert_equal( index, dir['indexFile'] )
+
+    dir['indexFile'] = 'index1.page'
+    assert_equal( nil, dir['indexFile'] )
+    dir['indexFile'] = 'index1.page'
+    index.path = 'index1.page'
+    assert_equal( index, dir['indexFile'] )
+
+    index.path = 'index.page'
+    dir['indexFile'] = nil
+    assert_equal( nil, dir['indexFile'] )
+  end
+
+end
+
+class DirectoryHandlerTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/directory.rb',
+    base_fixture_path( 'tc_filehandler_filehandler/sample_plugin.rb' )
+  ]
+  plugin_to_test 'File/DirectoryHandler'
+
+  def setup
+    super
+    @dirs = find_in_sample_site {|path| path =~ /\/$/ }.collect {|p| p.sub(/^#{sample_site( Webgen::SRC_DIR )}/, sample_site( 'out' ) )}
+    @root_dir = @dirs.min
+    @max_dir = @dirs.max
+  end
+
+  def test_create_node
+    root = @plugin.create_node( @root_dir, nil, {} )
+    assert_equal( @plugin, root.node_info[:processor] )
+    assert_equal( @root_dir, root.node_info[:src] )
+    dir = @plugin.create_node( @max_dir, root, {'test'=>'yes'} )
+    assert_equal( 'yes', dir['test'] )
+    dir1 = @plugin.create_node( @max_dir, root, {'test'=>'no'} )
+    assert_equal( 'yes', dir1['test'] )
+    assert_same( dir, dir1 )
+    assert_equal( File.basename( @max_dir ).capitalize, dir['title'] )
+  end
+
+  def test_write_node
+    root = @plugin.create_node( @root_dir, nil, {} )
+    root.path = @root_dir
+    dir_node = @plugin.create_node( @max_dir, root, {} )
+    dir_node.write_node
+    assert( File.directory?( dir_node.full_path ) )
+  ensure
+    FileUtils.rm_r( @root_dir, :force => true )
+  end
+
+  def test_recursive_create_path
+    root = @plugin.create_node( @root_dir, nil, {} )
+    root.path = @root_dir
+    root.node_info[:src] = @root_dir
+    dir_node = @plugin.recursive_create_path( @max_dir.sub( /^#{@root_dir}/, '' ), root )
+    dir_node.write_node
+    assert( File.directory?( @max_dir ) )
+  ensure
+    FileUtils.rm_r( @root_dir, :force => true )
+  end
+
+  def test_node_for_lang
+    # directory with index file
+    root = @manager['Core/FileHandler'].instance_eval { build_tree }
+    assert_equal( root.resolve_node( 'index.en.html' ), root.node_for_lang( Webgen::LanguageManager.language_for_code( 'en' ) ) )
+    assert_equal( root.resolve_node( 'index.de.html' ), root.node_for_lang( Webgen::LanguageManager.language_for_code( 'de' ) ) )
+
+    # directory without index file
+    dir1 = root.resolve_node( 'dir1' )
+    assert_equal( dir1, dir1.node_for_lang( Webgen::LanguageManager.language_for_code( 'de' ) ) )
+  end
+
+  def test_link_from
+    root = @manager['Core/FileHandler'].instance_eval { build_tree }
+
+    file11 = root.resolve_node( 'dir1/file11.html' )
+    assert_equal( '<a href="../index.en.html"></a>', root.link_from( file11 ) )
+    assert_equal( '<span>TestLink</span>',
+                  root.link_from( root.resolve_node( 'index.de.html' ), {:link_text => 'TestLink' } ) )
+
+    dir1 = root.resolve_node( 'dir1' )
+    assert_equal( '<a href="./">Dir1</a>', dir1.link_from( file11 ) )
+    assert_equal( '<a href="dir1/">TestLink</a>', dir1.link_from( root, {:link_text => 'TestLink' } ) )
+  end
+
+end
+

data/test/unittests/tc_filehandler_filehandler.rb

@@ -0,0 +1,294 @@
+require 'find'
+require 'fileutils'
+require 'webgen/test'
+require 'webgen/node'
+require 'webgen/config'
+
+class FileHandlerTest < Webgen::PluginTestCase
+
+  #TODO think about runtime depdencies  (e.g. Configuration for Core/FileHandler)
+  #     ie. ones which are not required for initializing, but for running
+  plugin_files [
+    'webgen/plugins/filehandlers/filehandler.rb',
+    'webgen/plugins/filehandlers/directory.rb',
+    fixture_path( 'sample_plugin.rb' ),
+  ]
+  plugin_to_test 'Core/FileHandler'
+
+  def setup
+    @websiteDir = nil
+    super
+  end
+
+  def param_for_plugin( plugin_name, param )
+    if [plugin_name, param] == ['Core/Configuration', 'websiteDir'] && @websiteDir
+      @websiteDir
+    else
+      super
+    end
+  end
+
+  def test_file_modified
+    modified = fixture_path( 'modified' )
+    unmodified = fixture_path( 'unmodified' )
+
+    assert( @plugin.file_modified?( unmodified, modified ) )
+    assert( !@plugin.file_modified?( unmodified, unmodified ) )
+    FileUtils.touch( modified )
+    assert( !@plugin.file_modified?( unmodified, modified ) )
+    assert( @plugin.file_modified?( modified, unmodified ) )
+  ensure
+    FileUtils.rm( modified, :force => true )
+  end
+
+  def test_find_all_files
+    found_files = @plugin.instance_eval {find_all_files}
+    files = find_in_sample_site {|p| p != sample_site( Webgen::SRC_DIR ) + '/' }
+    assert_equal( files, found_files )
+  end
+
+  def test_find_files_for_handlers
+    files_for_handlers = @plugin.instance_eval {find_files_for_handlers}
+    files = find_in_sample_site {|path| path =~ /\.page$/}
+
+    assert_equal( 2, files_for_handlers.length )
+    files_for_sample_handler = files_for_handlers.select {|r,p,f| p == @manager['SampleHandler']}
+    assert_not_nil( files_for_sample_handler )
+    assert_equal( files, files_for_sample_handler.first[2] )
+  end
+
+  def test_create_root_node
+    srcDir = @manager.param_for_plugin( 'Core/Configuration', 'srcDir' ) + '/'
+    outDir = @manager.param_for_plugin( 'Core/Configuration', 'outDir' ) + '/'
+
+    dir_handler = @manager.plugins.delete( 'File/DirectoryHandler' )
+    root = @plugin.instance_eval {create_root_node}
+    assert_nil( root )
+
+    @manager.plugins['File/DirectoryHandler'] = dir_handler
+    root = @plugin.instance_eval {create_root_node}
+    assert_kind_of( Node, root )
+    assert_equal( '', root['title'] )
+    assert_equal( outDir, root.path )
+    assert_equal( root.path, root.full_path )
+    assert_equal( srcDir, root.node_info[:src] )
+  end
+
+  def test_create_node_dir
+    dirs = find_in_sample_site {|path| File.directory?(path)}
+
+    root_node = @plugin.instance_eval {create_root_node}
+    dir_handler = @manager['File/DirectoryHandler']
+
+    max_dir = dirs.max
+
+    dir = @plugin.create_node( max_dir.sub( /^#{root_node.node_info[:src]}/, ''), root_node, dir_handler )
+    assert_not_nil( dir )
+    assert_equal( File.join( File.basename( max_dir ), '/' ), dir.path )
+    assert_equal( max_dir.sub(/^#{root_node.node_info[:src]}/, root_node.path), dir.full_path )
+    assert( dir.is_directory? )
+
+    n = root_node
+    while n.has_children?
+      assert( n.is_directory? )
+      assert_equal( 1, n.children.length, "node: #{n.children.collect{|c| c.path}.inspect}" )
+      n = n.children[0]
+    end
+
+    dir1 = @plugin.create_node( max_dir.sub( /^#{root_node.node_info[:src]}/, ''), root_node, dir_handler )
+    assert_same( dir, dir1 )
+  end
+
+  def test_create_node_file
+    pages = find_in_sample_site {|path| path =~ /\.page$/}
+
+    root_node = @plugin.instance_eval {create_root_node}
+    dir_handler = @manager['File/DirectoryHandler']
+    page_handler = @manager['SampleHandler']
+
+    max_page = pages.max
+    page = @plugin.create_node( max_page.sub( /^#{root_node.node_info[:src]}/, ''), root_node, page_handler )
+    assert_not_nil( page )
+    max_page_outpath = File.join( File.dirname( max_page.sub(/^#{root_node.node_info[:src]}/, root_node.path) ),
+                                  page_handler.class.out_name( max_page ) )
+    assert_equal( max_page_outpath, page.full_path )
+    assert( page.is_file? )
+
+    page1 = @plugin.create_node( max_page.sub( /^#{root_node.node_info[:src]}/, ''), root_node, page_handler )
+    assert_same( page, page1 )
+  end
+
+  def test_build_tree
+    outDir = @manager.param_for_plugin( 'Core/Configuration', 'outDir' ) + '/'
+
+    tree = @plugin.instance_eval {build_tree}
+    assert_not_nil( tree )
+    assert_equal( outDir, tree.full_path )
+    assert_equal( 6, tree.children.size )
+    assert_not_nil( tree.resolve_node( 'dir1/dir11/file111.html' ) )
+
+    nr_paths_on_disc = find_in_sample_site {|p| true }.length
+
+    def calc_length( tree ); tree.children.inject( 1 ) {|memo,c| memo += calc_length( c ) }; end
+
+    assert( calc_length( tree ), nr_paths_on_disc )
+  end
+
+  def test_load_meta_info_backing_file
+    @websiteDir = fixture_path('backing')
+    assert( File.exists?( @websiteDir ) )
+    @plugin.instance_eval { load_meta_info_backing_file }
+    assert_equal({'key1'=>'value1'}, @plugin.instance_eval { @source_backing['/file1'] })
+    assert_equal({}, @plugin.instance_eval { @output_backing })
+    @websiteDir = fixture_path('backing_empty')
+    assert( File.exists?( @websiteDir ) )
+    @plugin.instance_eval { @source_backing = nil; @output_backing = nil; load_meta_info_backing_file }
+    assert_equal({}, @plugin.instance_eval { @source_backing })
+  ensure
+    @websiteDir = nil
+  end
+
+  def test_meta_info_for
+    @plugin.instance_eval { @source_backing = {'/file'=>{'key'=>'novalue'},'ile'=>{'key'=>'false value'}} }
+    assert_equal( {'key'=>'value'}, @plugin.meta_info_for( @manager['SampleHandler'] ) )
+    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/file' ) )
+    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], 'file' ) )
+
+    @plugin.instance_eval { @source_backing = {'/file'=>{'key'=>'novalue'}} }
+    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/file' ) )
+    assert_equal( {'key'=>'value'}, @plugin.meta_info_for( @manager['SampleHandler'] ) )
+
+    @plugin.instance_eval { @source_backing = {'/dir'=>{'key'=>'novalue'}} }
+    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], 'dir' ) )
+    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/dir/' ) )
+    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/dir' ) )
+    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], 'dir/' ) )
+  end
+
+  def test_handle_output_backing
+    root = @plugin.instance_eval { create_root_node }
+    node = Node.new( Node.new( root, 'dir/' ), 'test1.html' )
+    node['test'] = 'yes'
+    @plugin.instance_eval { @output_backing = {
+        'api.html'=>{'url'=>'rdoc/index.html'},
+        '/doc/test.html'=>{'url'=>'http://www.webgen.com'},
+        'dir/test1.html'=>{'test'=>'no'}
+      }}
+    @plugin.instance_eval { handle_output_backing( root ) }
+
+    # test virtual node creation
+    assert_not_nil( root.resolve_node( 'rdoc/index.html' ) )
+    assert_not_nil( root.resolve_node( 'api.html' ) )
+    backed1 = root.resolve_node( 'api.html' )
+    assert_equal( 'api.html', backed1.node_info[:reference] )
+    assert_equal( @manager['File/VirtualFileHandler'], backed1.node_info[:processor] )
+
+    backed2 = root.resolve_node( 'doc/test.html' )
+    assert_not_nil( backed2 )
+
+    assert_equal( '<a href="../rdoc/index.html">rdoc/index.html</a>', backed1.link_from( node ) )
+    assert_equal( '<a href="http://www.webgen.com">http://www.webgen.com</a>', backed2.link_from( node ) )
+
+    # test setting of meta infos for existing nodes
+    assert_equal( 1, root.resolve_node( 'dir/' ).children.length )
+    assert_equal( 'no', node['test'] )
+  end
+
+end
+
+class DefaultHandlerTest < Webgen::PluginTestCase
+
+  plugin_files ['webgen/plugins/filehandlers/filehandler.rb']
+  plugin_to_test 'File/DefaultHandler'
+
+  def setup
+    super
+    @defHandlerClass = @manager.plugin_class_for_name( 'File/DefaultHandler' )
+    @plugin1 = @defHandlerClass.new( @manager )
+  end
+
+  def param_for_plugin( plugin_name, param )
+    if [plugin_name, param] == ['File/DefaultHandler', 'linkToCurrentPage'] && @link_to_current
+      @link_to_current
+    else
+      super
+    end
+  end
+
+  def test_initialization
+    assert_nil( @plugin )
+  end
+
+  def test_accessors
+    @defHandlerClass.class_eval do
+      register_path_pattern 'first'
+      register_path_pattern 'second', 10
+      register_extension 'fff'
+      register_extension 'ggg', 20
+
+      public :register_extension
+      public :register_path_pattern
+    end
+    @plugin1.register_path_pattern 'third'
+    @plugin1.register_path_pattern 'fourth', 30
+    @plugin1.register_extension 'hhh'
+    @plugin1.register_extension 'iii', 40
+
+    patterns = @plugin1.path_patterns.sort
+    [
+     [10, 'second'],
+     [20, @defHandlerClass::EXTENSION_PATH_PATTERN % ['ggg']],
+     [30, 'fourth'],
+     [40, @defHandlerClass::EXTENSION_PATH_PATTERN % ['iii']],
+     [@defHandlerClass::DEFAULT_RANK, 'first'],
+     [@defHandlerClass::DEFAULT_RANK, 'third'],
+     [@defHandlerClass::DEFAULT_RANK, @defHandlerClass::EXTENSION_PATH_PATTERN % ['fff']],
+     [@defHandlerClass::DEFAULT_RANK, @defHandlerClass::EXTENSION_PATH_PATTERN % ['hhh']]
+    ].each_with_index do |p, index|
+      if p[0] == @defHandlerClass::DEFAULT_RANK
+        assert( patterns.include?( p ), "#{p} missing" )
+      else
+        assert_equal( p, patterns[index] )
+      end
+    end
+  end
+
+  def test_methods_for_subclasses
+    assert_raise( NotImplementedError ) { @plugin1.create_node( nil, nil, nil ) }
+    assert_raise( NotImplementedError ) { @plugin1.write_node( nil ) }
+  end
+
+  def test_node_for_lang
+    node = Node.new( nil, 'path' )
+    de = Webgen::LanguageManager.language_for_code( 'de' )
+    en = Webgen::LanguageManager.language_for_code( 'en' )
+    assert_equal( node, @plugin1.node_for_lang( node, de ) )
+    assert_equal( node, @plugin1.node_for_lang( node, en ) )
+  end
+
+  def test_link_from
+    refNode = Node.new( nil, 'path' )
+    node = Node.new( refNode, '#frag' )
+    node['title'] = 'title'
+
+    assert_equal( '<a href="#frag">title</a>', @plugin1.link_from( node, refNode ) )
+    assert_equal( '<a href="#frag">link_text</a>',
+                  @plugin1.link_from( node, refNode, :link_text => 'link_text' ) )
+    assert_equal( '<a attr1="val1" href="#frag">link_text</a>',
+                  @plugin1.link_from( node, refNode, :link_text => 'link_text', 'attr1' => 'val1' ) )
+    assert_equal( '<a href="#frag">link_text</a>',
+                  @plugin1.link_from( node, refNode, :link_text => 'link_text', :attr1 => 'val1' ) )
+
+    node['linkAttrs'] = {:link_text => 'Default Text', 'class'=>'help'}
+    assert_equal( '<a attr1="val1" class="help" href="#frag">link_text</a>',
+                  @plugin1.link_from( node, refNode, :link_text => 'link_text', 'attr1' => 'val1' ) )
+
+    # Test param setting
+    node['linkAttrs'] = nil
+    @link_to_current = true
+    assert_equal( '<a href="#frag">title</a>', @plugin1.link_from( node, node ) )
+    @link_to_current = false
+    assert_equal( '<span>title</span>', @plugin1.link_from( node, node ) )
+  end
+
+end

data/test/unittests/tc_filehandler_gallery.rb

@@ -0,0 +1,165 @@
+require 'webgen/test'
+
+class GalleryInfoTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/gallery.rb',
+  ]
+
+  def setup
+    super
+    @ginfoclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo
+    @iclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo::Image
+    @gclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo::Gallery
+    @galleries = []
+    @galleries << @gclass.new( 'gal1.html', {},
+                              [@iclass.new( 'test1.html', {'thumbnail' => 'tn_test1.jpg'}, 'test1.jpg' ), @iclass.new( 'test2.html', {'thumbnailSize' => '100x50'}, 'test2.jpg' )] )
+    @galleries << @gclass.new( 'gal2.html', {},
+                              [@iclass.new( 'test3.html', {}, 'test3.jpg' ), @iclass.new( 'test4.html', {}, 'test4.jpg' )] )
+    @galleries << @gclass.new( 'gal3.html', {},
+                              [@iclass.new( 'test5.html', {}, 'test5.jpg' ), @iclass.new( 'test6.html', {}, 'test6.jpg' )] )
+  end
+
+  def create_ginfo( gindex = nil, iindex = nil )
+    @ginfoclass.new( {:galleries => @galleries}, gindex, iindex )
+  end
+
+  def test_cur_image
+    assert_equal( @galleries[0].images[0], create_ginfo( 0, 0 ).cur_image )
+  end
+
+  def test_cur_gallery
+    assert_equal( @galleries[0], create_ginfo( 0 ).cur_gallery )
+  end
+
+  def test_prev_image
+    assert_equal( nil, create_ginfo( 0, 0 ).prev_image )
+    assert_equal( @galleries[0].images[0], create_ginfo( 0, 1 ).prev_image )
+    assert_equal( @galleries[0].images[1], create_ginfo( 1, 0 ).prev_image )
+  end
+
+  def test_next_image
+    assert_equal( nil, create_ginfo( 2, 1 ).next_image )
+    assert_equal( @galleries[0].images[1], create_ginfo( 0, 0 ).next_image )
+    assert_equal( @galleries[1].images[0], create_ginfo( 0, 1 ).next_image )
+  end
+
+  def test_prev_gallery
+    assert_equal( nil, create_ginfo( 0 ).prev_gallery )
+    assert_equal( @galleries[0], create_ginfo( 1 ).prev_gallery )
+  end
+
+  def test_next_gallery
+    assert_equal( nil, create_ginfo( 2 ).next_gallery )
+    assert_equal( @galleries[1], create_ginfo( 0 ).next_gallery )
+  end
+
+  def test_image_accessors
+    ginfo = create_ginfo( 0, 0 )
+    assert_equal( '<img src="{relocatable: tn_test1.jpg}" alt="" />', ginfo.cur_image.thumbnail )
+    assert_equal( '<img src="{relocatable: test2.jpg}" width="100" height="50" alt="" />', ginfo.next_image.thumbnail )
+  end
+
+  def test_gallery_accessors
+    ginfo = create_ginfo( 0, 0 )
+    assert_equal( '<img src="{relocatable: tn_test1.jpg}" alt="" />', ginfo.cur_gallery.thumbnail )
+    assert_equal( '<img src="{relocatable: test3.jpg}" width="" height="" alt="" />', ginfo.next_gallery.thumbnail )
+  end
+
+end
+
+class GalleryFileHandlerTest < Webgen::PluginTestCase
+
+  plugin_files [
+    'webgen/plugins/filehandlers/directory.rb',
+    'webgen/plugins/filehandlers/gallery.rb'
+  ]
+  plugin_to_test 'File/GalleryHandler'
+
+  def test_param
+    assert_nothing_raised { @plugin.instance_eval { param('imagesPerPage') } }
+  end
+
+  def test_create_node
+    ginfoclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo
+
+    root = Node.new( nil, '/' )
+    root.node_info[:src] = fixture_path
+
+    # with a main page
+    assert_nil( @plugin.create_node( fixture_path( 'test.gallery' ), root, {} ) )
+    assert_not_nil( root.resolve_node( 'Test.page' ) )
+    assert_not_nil( root.resolve_node( 'Test_1.page' ) )
+    assert_not_nil( root.resolve_node( 'Test_2.page' ) )
+    assert_not_nil( root.resolve_node( 'Test_test1_jpg.page' ) )
+    assert_not_nil( root.resolve_node( 'Test_test2_jpg.page' ) )
+    assert_not_nil( root.resolve_node( 'Test_test3_jpg.page' ) )
+    assert_not_nil( root.resolve_node( 'Test_test4_jpg.page' ) )
+
+    node = root.resolve_node( 'Test_test3_jpg.page' )
+    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
+    assert_equal( 'test3.jpg', node.node_info[:ginfo].cur_image.filename )
+    assert_equal( node.path, node.node_info[:ginfo].cur_image.pagename )
+    assert_equal( 'gallery_image.template', node['template'] )
+
+    node = root.resolve_node( 'Test_2.page' )
+    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
+    assert_equal( node.path, node.node_info[:ginfo].cur_gallery.pagename )
+    assert_equal( 'gallery_gallery.template', node['template'] )
+
+    node = root.resolve_node( 'Test.page' )
+    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
+    assert_equal( 'gallery_main.template', node['template'] )
+
+    # without a main page
+    root.del_children
+    @plugin.create_node( fixture_path( 'test1.gallery' ), root, {} )
+    assert_not_nil( root.resolve_node( 'Test1.page' ) )
+    assert_nil( root.resolve_node( 'Test1_1.page' ) )
+    assert_nil( root.resolve_node( 'Test1_2.page' ) )
+    assert_not_nil( root.resolve_node( 'Test1_test1_jpg.page' ) )
+    assert_not_nil( root.resolve_node( 'Test1_test2_jpg.page' ) )
+    assert_not_nil( root.resolve_node( 'Test1_test3_jpg.page' ) )
+    assert_not_nil( root.resolve_node( 'Test1_test4_jpg.page' ) )
+
+    node = root.resolve_node( 'Test1.page' )
+    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
+    assert_equal( 'gallery_gallery.template', node['template'] )
+  end
+
+end
+
+begin
+
+  require 'RMagick'
+
+  class ThumbnailWriterTest < Webgen::PluginTestCase
+
+    plugin_files [
+                  'webgen/plugins/filehandlers/directory.rb',
+                  'webgen/plugins/filehandlers/gallery.rb'
+                 ]
+    plugin_to_test 'File/ThumbnailWriter'
+
+    def test_create_node
+      node = @plugin.create_node( 'testfor anddo.jpg', nil, {}, '100x100' )
+      assert_equal( 'tn_testfor_anddo.jpg', node.path )
+      assert_equal( 'testfor anddo.jpg', node.node_info[:thumbnail_file] )
+      assert_equal( '100x100', node.node_info[:thumbnail_size] )
+    end
+
+    def test_gallery_thumbnail_creation
+      root = Node.new( nil, '/' )
+      root.node_info[:src] = fixture_path
+
+      @manager['File/GalleryHandler'].create_node( fixture_path( 'test.gallery' ), root, {} )
+      tn_node = root.resolve_node( 'tn_test1.jpg' )
+      assert_not_nil( tn_node )
+      assert_equal( fixture_path( 'test1.jpg' ), tn_node.node_info[:thumbnail_file] )
+      assert_equal( tn_node.absolute_path, root.resolve_node( 'Test_test1_jpg.page' ).node_info[:ginfo].cur_image.data['thumbnail'] )
+    end
+
+  end
+
+rescue LoadError
+end