webgen 0.5.17 → 1.0.0.beta1

data/test/{test_languages.rb → webgen/test_languages.rb}

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'webgen/languages'
 
-class TestLanguages < Test::Unit::TestCase
+class TestLanguages < MiniTest::Unit::TestCase
 
   def test_get_language
     assert_nil(Webgen::LanguageManager.language_for_code(nil))
@@ -16,7 +16,7 @@ class TestLanguages < Test::Unit::TestCase
     [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)
+    refute_equal(lang4, lang2)
   end
 
   def test_find_language
@@ -59,7 +59,7 @@ class TestLanguages < Test::Unit::TestCase
     assert_equal(de, h[de])
     assert_equal(de, h['de'])
     assert_equal(en, h[en])
-    assert_not_equal(en, h['en']) # bc 'en'.eql?(en) is false
+    refute_equal(en, h['en']) # bc 'en'.eql?(en) is false
     assert_equal(Webgen::LanguageManager.language_for_code('en'),
                  Webgen::LanguageManager.language_for_code(en))
   end

data/test/webgen/test_logger.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'stringio'
+require 'webgen/logger'
+
+class TestLogger < MiniTest::Unit::TestCase
+
+  def test_logging
+    @logio = StringIO.new
+    logger = Webgen::Logger.new(@logio)
+    logger.formatter = Proc.new do |severity, timestamp, progname, msg|
+      "#{severity} #{msg}\n"
+    end
+
+    logger.verbose = false
+    logger.debug { ["debug", "verbose"]}
+    assert_log(/^DEBUG debug$/)
+    logger.info {["info", "verbose"]}
+    assert_log(/^INFO info$/)
+    logger.warn {["warn", "verbose"]}
+    assert_log(/^WARN warn$/)
+    logger.error {["error", "verbose"]}
+    assert_log(/^ERROR error$/)
+    logger.vinfo {["verbose", "verbose"]}
+    assert_log(/^$/)
+
+    logger.verbose = true
+    logger.debug { ["debug", "verbose"]}
+    assert_log(/^DEBUG debug\nverbose$/)
+    logger.info {["info", "verbose"]}
+    assert_log(/^INFO info\nverbose$/)
+    logger.warn {["warn", "verbose"]}
+    assert_log(/^WARN warn\nverbose$/)
+    logger.error {["error", "verbose"]}
+    assert_log(/^ERROR error\nverbose$/)
+    logger.vinfo {["verbose", "verbose"]}
+    assert_log(/^INFO verbose\nverbose$/)
+  end
+
+  def assert_log(reg)
+    assert_match(reg, @logio.string)
+    @logio.string = ''
+  end
+
+end

data/test/webgen/test_node.rb

@@ -0,0 +1,178 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/node'
+
+class TestNode < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    setup_website
+  end
+
+  def test_initialize
+    check_proc = proc do |node, parent, dest_path, cn, lcn, alcn, lang, mi|
+      assert_equal(parent, node.parent)
+      assert_equal(dest_path, node.dest_path)
+      assert_equal(cn, node.cn)
+      assert_equal(lcn, node.lcn)
+      assert_equal(alcn, node.alcn)
+      assert_equal(lang, node.lang)
+      assert_kind_of(Webgen::Language, node.lang) if node.lang
+      assert_equal(mi, node.meta_info)
+      assert_equal({}, node.node_info)
+    end
+
+    node = Webgen::Node.new(@website.tree.dummy_root, '/', '/', {'lang' => 'de', :test => :value})
+    check_proc.call(node, @website.tree.dummy_root, '/', '/', '/', '/', nil, {:test => :value})
+
+    child = Webgen::Node.new(node, 'somename.html', '/somename.html',  {'lang' => 'de'})
+    check_proc.call(child, node, '/somename.html', 'somename.html', 'somename.de.html',
+                    '/somename.de.html', 'de', {})
+
+    ['http://webgen.rubyforge.org', 'c:\\test'].each_with_index do |abspath, index|
+      cn = "test#{index}.html"
+      c = Webgen::Node.new(node, cn, abspath)
+      check_proc.call(c, node, abspath, cn, cn, '/' + cn, nil, {})
+    end
+  end
+
+  def test_type_checkers
+    setup_default_nodes(@website.tree)
+    assert(@website.tree['/'].is_directory?)
+    assert(@website.tree['/file.en.html'].is_file?)
+    assert(@website.tree['/file.en.html#frag'].is_fragment?)
+    assert(@website.tree['/'].is_root?)
+    assert(!@website.tree['/file.en.html'].is_root?)
+    assert(@website.tree['/file.en.html#nested'].is_fragment?)
+    assert(!@website.tree['/file.en.html#nested'].is_directory?)
+  end
+
+  def test_is_ancestor_of
+    setup_default_nodes(@website.tree)
+
+    assert(@website.tree['/'].is_ancestor_of?(@website.tree['/file.en.html']))
+    assert(@website.tree['/'].is_ancestor_of?(@website.tree['/dir/']))
+
+    assert(@website.tree['/dir/'].is_ancestor_of?(@website.tree['/dir/subfile.html']))
+
+    assert(@website.tree['/'].is_ancestor_of?(@website.tree['/dir/subfile.html#frag']))
+    assert(@website.tree['/dir/'].is_ancestor_of?(@website.tree['/dir/subfile.html#frag']))
+    assert(@website.tree['/dir/subfile.html'].is_ancestor_of?(@website.tree['/dir/subfile.html#frag']))
+
+    refute(@website.tree['/dir/'].is_ancestor_of?(@website.tree['/dir2/index.en.html']))
+    refute(@website.tree['/dir/'].is_ancestor_of?(@website.tree['/file.en.html']))
+    refute(@website.tree['/dir/subfile.html'].is_ancestor_of?(@website.tree['/file.en.html']))
+    refute(@website.tree['/dir2/index.en.html'].is_ancestor_of?(@website.tree['/dir/subfile.html']))
+  end
+
+  def test_to_s
+    node = Webgen::Node.new(@website.tree.dummy_root, '/', '/', {'lang' => 'de', :test => :value})
+    assert_equal(node.alcn, node.to_s)
+  end
+
+  def test_matching
+    root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'somefile.html', 'somefile.de.html', {'lang' => 'de'})
+    assert(node =~ '**/*')
+    assert(node =~ '**/somefile.de.HTML')
+    assert(node =~ '/**/somefile.*.html')
+    assert(node !~ '/somefile.html')
+    assert(node !~ '**/*.test')
+  end
+
+  def test_method_missing
+    node = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    assert_raises(NoMethodError) { node.unknown }
+    refute(node.respond_to?(:unknown))
+
+    path_handler = Object.new
+    def path_handler.unknown(node); :value; end
+    node.node_info[:path_handler] = path_handler
+
+    assert(node.respond_to?(:unknown))
+    assert_equal(:value, node.unknown)
+  end
+
+  def test_route_to
+    tree = @website.tree
+    setup_default_nodes(tree)
+
+    assert_equal('file.en.html', tree['/file.en.html'].route_to(tree['/file.en.html']))
+    assert_equal('file.de.html', tree['/file.en.html#frag'].route_to(tree['/file.de.html']))
+    assert_equal('subfile.html#frag', tree['/dir/'].route_to(tree['/dir/subfile.html#frag']))
+    assert_equal('#frag', tree['/dir/subfile.html'].route_to(tree['/dir/subfile.html#frag']))
+    assert_equal('../dir2/index.en.html', tree['/dir/subfile.html#frag'].route_to(tree['/dir2/index.en.html']))
+    assert_equal('../dir2/index.en.html', tree['/dir/subfile.html'].route_to(tree['/dir2/index.en.html']))
+
+    assert_equal('./', tree['/file.en.html'].route_to(tree['/']))
+    assert_equal('../', tree['/dir/'].route_to(tree['/']))
+    assert_equal('dir/', tree['/file.en.html'].route_to(tree['/dir/']))
+
+    n = Webgen::Node.new(tree['/'], 'testing', '../../.././dir2')
+    assert_equal('../dir2', tree['/dir/subfile.html'].route_to(n))
+  end
+
+  def test_proxy_node
+    tree = @website.tree
+    setup_default_nodes(tree)
+
+    assert_equal(tree['/file.en.html'], tree['/file.en.html'].proxy_node('en'))
+    assert_equal(tree['/dir2/index.en.html'], tree['/dir2/'].proxy_node('en'))
+    assert_equal(tree['/dir2/index.en.html'], tree['/dir2/'].proxy_node('en'))
+
+    @website.ext.item_tracker = MiniTest::Mock.new
+    @website.ext.item_tracker.expect(:add, nil, [:a, :b, :c, :d])
+    tree['/dir/subfile.html'].meta_info['proxy_path'] = 'holla'
+    assert_equal(tree['/dir/subfile.html'], tree['/dir/subfile.html'].proxy_node('pt'))
+  end
+
+  def test_level
+    setup_default_nodes(@website.tree)
+    assert_equal(0, @website.tree['/'].level)
+    assert_equal(1, @website.tree['/dir/'].level)
+    assert_equal(2, @website.tree['/dir/subfile.html'].level)
+    assert_equal(3, @website.tree['/dir/dir/file.html'].level)
+  end
+
+  def test_link_to
+    tree = @website.tree
+    setup_default_nodes(tree)
+
+    # general tests
+    assert_equal('<a href="#frag">frag</a>',
+                 tree['/file.en.html'].link_to(tree['/file.en.html#frag']))
+    assert_equal('<a href="#frag">link_text</a>',
+                 tree['/file.en.html'].link_to(tree['/file.en.html#frag'], 'en', :link_text => 'link_text'))
+    assert_equal('<a attr1="val1" href="#frag">frag</a>',
+                 tree['/file.en.html'].link_to(tree['/file.en.html#frag'], 'en', 'attr1' => 'val1'))
+    assert_equal('<a href="#frag">frag</a>',
+                 tree['/file.en.html'].link_to(tree['/file.en.html#frag'], 'en', :attr1 => 'val1'))
+    assert_equal('<a class="help" href="dir2/index.en.html" hreflang="en">index en</a>',
+                 tree['/file.en.html'].link_to(tree['/dir2/index.en.html']))
+
+    # links to directories
+    assert_equal('<a href="dir2/index.de.html" hreflang="de">routed de</a>',
+                 tree['/file.de.html'].link_to(tree['/dir2/']))
+    assert_equal('<a href="dir2/index.en.html" hreflang="en">routed</a>',
+                 tree['/file.en.html'].link_to(tree['/dir2/']))
+    assert_equal('<a href="dir2/index.de.html" hreflang="de">routed de</a>',
+                 tree['/file.en.html'].link_to(tree['/dir2/'], 'de'))
+  end
+
+  def test_versions
+    root = Webgen::Node.new(Webgen::Tree.new('website').dummy_root, '/', '/')
+    n1 = Webgen::Node.new(root, 'file.html', '/file.html', 'version' => 'html')
+    n1.node_info[:path] = '/file.html'
+    n2 = Webgen::Node.new(root, 'file.pdf', '/file.pdf', 'version' => 'pdf')
+    n2.node_info[:path] = '/file.html'
+    n3 = Webgen::Node.new(root, 'file.orig', '/file.orig', 'version' => 'html')
+    n3.node_info[:path] = '/file.other'
+
+    assert_equal({'html' => n1, 'pdf' => n2}, n1.versions)
+    assert_equal({'html' => n1, 'pdf' => n2}, n2.versions)
+    assert_equal({'html' => n3}, n3.versions)
+  end
+
+end

data/test/webgen/test_node_finder.rb

@@ -0,0 +1,127 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/node_finder'
+
+class TestNodeFinder < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    @config = {}
+    setup_website(@config)
+    @nf = Webgen::NodeFinder.new(@website)
+  end
+
+  def test_add_filter_module
+    m = Module.new
+    m.send(:define_method, :filter_something) { :value }
+
+    assert_raises(ArgumentError) { @nf.add_filter_module(m, :name => 'unknown_method') }
+    assert_raises(NoMethodError) { @nf.filter_something }
+    @nf.add_filter_module(m, :something => 'filter_something')
+    assert_equal('filter_something', @nf.instance_eval { @mapping[:something] })
+    assert_equal(:value, @nf.filter_something)
+  end
+
+  def test_find
+    setup_default_nodes(@website.tree)
+    tree = @website.tree
+
+    check = lambda do |correct, result|
+      assert_equal(correct.collect {|n| tree[n]}, result, "Failure at #{caller[0]}")
+    end
+    @config['node_finder.option_sets'] = {'simple' => {:alcn => '', :unknown => ''}}
+
+    assert_raises(ArgumentError) { @nf.find(['hallo'], tree['/']) }
+
+    # test using configured search options
+    check.call(%w[/], @nf.find('simple', tree['/']))
+    check.call(%w[/file.en.html], @nf.find('simple', tree['/file.en.html']))
+
+    # test limit, offset, flatten, levels
+    check.call(%w[/file.en.html /other.en.html],
+               @nf.find({:alcn => '/**/*.en.html', :limit => 2}, tree['/']))
+    check.call(%w[/dir2/index.en.html],
+               @nf.find({:alcn => '/**/*.en.html', :limit => 2, :offset => 2}, tree['/']))
+
+    assert_equal([[tree['/file.en.html'], [tree['/file.en.html#frag']]],
+                  [tree['/file.de.html'], [tree['/file.de.html#frag']]],
+                  tree['/other.html'],
+                  tree['/other.en.html'],
+                  tree['/german.de.html'],
+                  [tree['/dir/'], [tree['/dir/subfile.html'], tree['/dir/dir/']]],
+                  [tree['/dir2/'], [tree['/dir2/index.en.html'], tree['/dir2/index.de.html']]]
+                 ],
+                 @nf.find({:levels => [1,2]}, tree['/']))
+
+    # test sort methods
+    check.call(%w[/file.en.html /file.de.html /dir/dir/file.html /german.de.html /dir2/index.de.html
+                  /dir2/index.en.html /other.html /other.en.html /dir/subfile.html],
+               @nf.find({:alcn => '/**/*.html', :flatten => true, :sort => true}, tree['/']))
+    check.call(%w[/german.de.html /other.en.html /other.html /file.en.html /file.de.html],
+               @nf.find({:alcn => '/*.html', :flatten => true, :sort => 'sort_info'}, tree['/']))
+    check.call(%w[/dir/dir/file.html /file.de.html /file.en.html /german.de.html /dir2/index.de.html /dir2/index.en.html
+                  /other.html /other.en.html /dir/subfile.html],
+               @nf.find({:alcn => '/**/*.html', :name => 'test', :flatten => true, :sort => 'title'}, tree['/']))
+    assert_equal([[tree['/file.en.html'], [[tree['/file.en.html#frag'], [tree['/file.en.html#nested']]]]],
+                  [tree['/file.de.html'], [tree['/file.de.html#frag']]],
+                  [tree['/dir/'], [[tree['/dir/dir/'], [tree['/dir/dir/file.html']]],
+                                   [tree['/dir/subfile.html'], [tree['/dir/subfile.html#frag']]]]],
+                  [tree['/dir2/'], [tree['/dir2/index.de.html'], tree['/dir2/index.en.html']]],
+                  tree['/german.de.html'], tree['/other.html'], tree['/other.en.html'],
+                 ],
+                 @nf.find({:levels => [1,3], :sort => true}, tree['/']))
+
+    # test filter: meta info keys/values
+    check.call(['/file.en.html#frag', '/file.de.html#frag', '/dir/subfile.html#frag'],
+               @nf.find({:mi => {'title' => 'frag'}, :flatten => true}, tree['/']))
+
+    # test filter: alcn
+    check.call(%w[/],
+               @nf.find({:alcn => '/'}, tree['/']))
+    check.call(%w[/ /dir/subfile.html /dir/subfile.html#frag /dir/dir/],
+               @nf.find({:alcn => ['/', '*'], :flatten => true}, tree['/dir/']))
+
+    # test filter: and/or/not
+    check.call(%w[/file.en.html /file.de.html /other.html /other.en.html /german.de.html ],
+               @nf.find({:alcn => '/**/*.html', :and => {:alcn => '*.html'}, :flatten => true}, tree['/']))
+    check.call(%w[/file.en.html /file.de.html /other.html /other.en.html /german.de.html /dir/subfile.html /dir/dir/file.html
+                  /dir2/index.en.html /dir2/index.de.html /],
+               @nf.find({:alcn => '/**/*.html', :or => 'simple', :flatten => true}, tree['/']))
+    check.call(%w[/dir/subfile.html /dir/dir/file.html /dir2/index.en.html /dir2/index.de.html],
+               @nf.find({:alcn => '/**/*.html', :not => {:alcn => '*.html'}, :flatten => true}, tree['/']))
+
+    # test filter: levels
+    check.call(%w[/],
+               @nf.find({:levels => [0, 0], :flatten => true}, tree['/dir/']))
+    check.call(%w[/file.en.html#nested /dir/subfile.html#frag /dir/dir/file.html],
+               @nf.find({:levels => [3,3], :flatten => true}, tree['/dir/']))
+    check.call(%w[/ /file.en.html /file.de.html /other.html /other.en.html /german.de.html /dir/ /dir2/],
+               @nf.find({:levels => [0,1], :flatten => true}, tree['/dir/']))
+
+    # test filter: langs
+    check.call(%w[/file.en.html /other.en.html /dir2/index.en.html],
+               @nf.find({:lang => 'en', :flatten => true}, tree['/dir/']))
+    check.call(%w[/file.en.html /file.de.html /other.en.html /german.de.html /dir2/index.en.html /dir2/index.de.html],
+               @nf.find({:lang => ['en', 'de'], :flatten => true}, tree['/dir/']))
+    check.call(%w[/file.en.html /other.en.html /dir2/index.en.html],
+               @nf.find({:lang => :node, :flatten => true}, tree['/file.en.html']))
+
+    # test filter: ancestors
+    check.call(%w[/ /dir/ /dir/dir/ /dir/dir/file.html],
+               @nf.find({:ancestors => true, :flatten => true}, tree['/dir/dir/file.html']))
+    check.call(%w[/ /dir/ /dir/dir/],
+               @nf.find({:ancestors => true, :flatten => true}, tree['/dir/dir/']))
+
+    # test filter: descendants
+    check.call(%w[/dir/ /dir/subfile.html /dir/subfile.html#frag /dir/dir/ /dir/dir/file.html],
+               @nf.find({:descendants => true, :flatten => true}, tree['/dir/']))
+
+    # test filter: siblings
+    check.call(%w[/file.en.html /file.de.html /other.html /other.en.html /german.de.html /dir/ /dir2/],
+               @nf.find({:siblings => true, :flatten => true}, tree['/dir/']))
+
+  end
+
+end

data/test/{test_page.rb → webgen/test_page.rb}

@@ -1,21 +1,9 @@
 # -*- encoding: utf-8 -*-
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'webgen/page'
 
-class TestBlock < Test::Unit::TestCase
-
-  def test_render
-    block = Webgen::Page::Block.new('content', 'some content', {'pipeline' => 'test'})
-    context = {:processors => {}}
-    assert_raise(RuntimeError) { block.render(context) }
-    context[:processors]['test'] = lambda {|context| context[:content] = context[:content].reverse + context[:block].name }
-    assert_equal('some content'.reverse + 'content', block.render(context)[:content])
-  end
-
-end
-
-class TestPage < Test::Unit::TestCase
+class TestPage < MiniTest::Unit::TestCase
 
   VALID = <<EOF
 # with more blocks
@@ -94,20 +82,45 @@ class TestPage < Test::Unit::TestCase
     - name: block1
       content: ''
 
+# named blocks using simple scheme
+- in: |
+    --- block1
+    content1
+    --- block2
+    content2
+    --- block3
+    content3
+    --- block4 -
+    content4
+    --- block5 -----------------------------------
+    content5
+  meta_info: {}
+  blocks:
+    - name: block1
+      content: content1
+    - name: block2
+      content: content2
+    - name: block3
+      content: content3
+    - name: block4
+      content: content4
+    - name: block5
+      content: "content5\\n"
+
 # named block and block with other options
 - in: |
-    --- name:block
+    --- name:block -------------------------------
     content doing -
     with?: with some things
 
-    --- other:options test1:true test2:false test3:542 pipeline:
-  meta_info: {}
+    --- other:options test1:true test2:false test3:542 pipeline: ----------------
+  meta_info:
+    blocks: {block2: {other: options, test1: true, test2: false, test3: 542, pipeline: ~}}
   blocks:
     - name: block
       content: "content doing -\\nwith?: with some things\\n"
     - name: block2
       content: ''
-      options: {other: options, test1: true, test2: false, test3: 542, pipeline: ~}
 
 # block with seemingly block start line it
 - in: |
@@ -174,59 +187,42 @@ EOF
   dfdf
   --- name, incorrect_format
   lsldf
+
+# invalid ending of block options
+- |
+  asdfasd
+  dfdf
+  --- name:block -- ---
+  lsldf
 EOF
 
   def test_invalid_pagefiles
     testdata = YAML::load(INVALID_MI)
     testdata.each_with_index do |data, index|
-      assert_raise(Webgen::Page::FormatError, "test mi item #{index}") { Webgen::Page.from_data(data) }
-      assert_raise(Webgen::Page::FormatError, "test mi item #{index}") { Webgen::Page.meta_info_from_data(data) }
+      assert_raises(Webgen::Page::FormatError, "test mi item #{index}") { Webgen::Page.from_data(data) }
     end
     testdata = YAML::load(INVALID_BLOCKS)
     testdata.each_with_index do |data, index|
-      assert_raise(Webgen::Page::FormatError, "test blocks item #{index}") { Webgen::Page.from_data(data) }
+      assert_raises(Webgen::Page::FormatError, "test blocks item #{index}") { Webgen::Page.from_data(data) }
     end
   end
 
   def test_valid_pagefiles
     YAML::load(VALID).each_with_index do |data, oindex|
-      mi = Webgen::Page.meta_info_from_data(data['in'])
-      assert_equal(data['meta_info'], mi, "test item #{oindex} - meta info directly")
       d = Webgen::Page.from_data(data['in'])
       assert_equal(data['meta_info'], d.meta_info, "test item #{oindex} - meta info all")
-      assert_equal(data['blocks'].length*2, d.blocks.length)
+      assert_equal(data['blocks'].length, d.blocks.length)
       data['blocks'].each_with_index do |b, index|
         index += 1
-        assert_equal(b['name'], d.blocks[index].name, "test item #{oindex} - name")
-        assert_equal(b['content'], d.blocks[index].content, "test item #{oindex} - content")
-        assert_equal(b['options'] || {}, d.blocks[index].options, "test item #{oindex} - options")
-        assert_same(d.blocks[index], d.blocks[b['name']])
+        assert_equal(b['content'], d.blocks[b['name']], "test item #{oindex} - content")
       end
     end
   end
 
-  def test_default_values
-    valid = YAML::load(VALID)
-    d = Webgen::Page.from_data(valid[0]['in'], 'blocks' => {1 => { 'name' => 'other1'}, 2 => { 'name' => 'block7'}})
-    assert_equal({'key' => 'value'}, d.meta_info)
-    assert_equal('other1', d.blocks[1].name)
-    assert_equal('block7', d.blocks[2].name)
-  end
-
   def test_eol_encodings
-    d = Webgen::Page.from_data("---\ntitle: test\r---\r\ncontent")
+    d = Webgen::Page.from_data("---\ntitle: test\r\n---\r\ncontent")
     assert_equal({'title' => 'test'}, d.meta_info)
-    assert_equal('content', d.blocks['content'].content)
-  end
-
-  def test_meta_info_dupped
-    mi = {'key' => 'value'}
-    d = Webgen::Page.from_data("---\ntitle: test\n---\ncontent", mi)
-    assert_equal({'title' => 'test', 'key' => 'value'}, d.meta_info)
-    assert_not_same(mi, d.meta_info)
-    d = Webgen::Page.from_data("content", mi)
-    assert_equal({'key' => 'value'}, d.meta_info)
-    assert_not_same(mi, d.meta_info)
+    assert_equal('content', d.blocks['content'])
   end
 
 end