webgen 0.5.17 → 1.0.0.beta1

data/test/webgen/test_content_processor.rb

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/content_processor'
+
+class Webgen::ContentProcessor::MyProcessor
+
+  def self.call(context)
+    raise Webgen::Error.new('msg') if context == 'webgen'
+    raise 'msg' if context == 'error'
+    context + 'value'
+  end
+
+end
+
+class TestContentProcessor < MiniTest::Unit::TestCase
+
+  def setup
+    @cp = Webgen::ContentProcessor.new
+  end
+
+  def test_register
+    @cp.register('Webgen::ContentProcessor::MyProcessor')
+    assert(@cp.registered?('my_processor'))
+    refute(@cp.is_binary?('my_processor'))
+
+    @cp.register('MyProcessor')
+    assert(@cp.registered?('my_processor'))
+    refute(@cp.is_binary?('my_processor'))
+
+    @cp.register('MyProcessor', :type => :binary, :name => 'test', :ext_map => {:a => :b})
+    assert(@cp.registered?('test'))
+    assert(@cp.is_binary?('test'))
+    assert_equal({:a => :b}, @cp.extension_map('test'))
+    assert_equal({:a => :b}, @cp.extension_map)
+    assert_equal([:test, :b], @cp.map_extension(:a))
+    assert_nil(@cp.map_extension(:b))
+
+    @cp.register('doit') do |context|
+      context.content = 'Nothing left.'
+    end
+    assert(@cp.registered?('doit'))
+    refute(@cp.is_binary?('doit'))
+  end
+
+  def test_is_binary
+    @cp.register('MyProcessor', :type => :text)
+    refute(@cp.is_binary?('m_yprocessor'))
+    @cp.register('MyProcessor', :type => :binary)
+    assert(@cp.is_binary?('my_processor'))
+    refute(@cp.is_binary?('unknown contentprocessor'))
+  end
+
+  def test_call
+    @cp.register('MyProcessor')
+    @cp.register('Webgen::ContentProcessor::MyProcessor', :name => 'other')
+    @cp.register('doit') do |context|
+      raise 'msg' if context == 'error'
+      context + 'value'
+    end
+
+    assert_equal('valuevalue', @cp.call('my_processor', 'value'))
+    assert_equal('valuevalue', @cp.call('other', 'value'))
+    assert_equal('valuevalue', @cp.call('doit', 'value'))
+
+    s = 'webgen'
+    def s.dest_node; "dest_node"; end
+    assert_raises(Webgen::Error) { @cp.call('my_processor', s) }
+
+    s = 'error'
+    def s.dest_node; "dest_node"; end
+    assert_raises(Webgen::RenderError) { @cp.call('my_processor', s) }
+    assert_raises(Webgen::RenderError) { @cp.call('doit', s) }
+  end
+
+  def test_normalize_pipeline
+    @cp.register('MyProcessor')
+    @cp.register('MyProcessor', :name => 'other')
+    assert_equal(['my_processor', 'other', 'other'], @cp.normalize_pipeline('my_processor,other,other'))
+    assert_equal(['my_processor', 'other', 'other'], @cp.normalize_pipeline('my_processor, other, other'))
+    assert_equal(['my_processor', 'other', 'other'], @cp.normalize_pipeline(['my_processor','other','other']))
+
+    assert_raises(Webgen::Error) { @cp.normalize_pipeline('unknown') }
+  end
+
+end

data/test/webgen/test_context.rb

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/context'
+
+class TestContext < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  module TestModule
+    def hallo
+      "hallo"
+    end
+  end
+
+  def setup
+    setup_website
+    @context = Webgen::Context.new(@website, :content => 'test', :key => :value, :chain => [:first, :last])
+  end
+
+  def test_initialize
+    @website.ext.context_modules = [TestModule];
+    context = Webgen::Context.new(@website)
+    assert_equal('', context.content)
+    assert_equal({}, context.persistent)
+    assert_same(@website.object_id, context.website.object_id)
+    assert_equal('hallo', context.hallo)
+
+    context = Webgen::Context.new(@website, :content => 'test', :key => :value)
+    assert_equal('test', context.content)
+    assert_equal(:value, context[:key])
+    assert_equal({}, context.persistent)
+
+    context = Webgen::Context.new(@website, {:content => 'test', :key => :value}, {:other => :val})
+    assert_equal('test', context.content)
+    assert_equal(:value, context[:key])
+    assert_equal({:other => :val}, context.persistent)
+  end
+
+  def test_clone
+    other = @context.clone(:content => 'new', :key => :other)
+    assert_equal('new', other.content)
+    assert_equal(:other, other[:key])
+    assert_equal([:first, :last], other[:chain])
+  end
+
+  def test_accessors
+    assert_equal(:value, @context[:key])
+    assert_equal([:first, :last], @context[:chain])
+    assert_equal('test', @context.content)
+    @context[:key] = :newvalue
+    assert_equal(:newvalue, @context[:key])
+  end
+
+  def test_node_methods
+    assert_equal(:first, @context.ref_node)
+    assert_equal(:last, @context.content_node)
+    assert_equal(:last, @context.dest_node)
+    @context[:dest_node] = :other
+    assert_equal(:other, @context.dest_node)
+  end
+
+  def test_tags_methods
+    context = Webgen::Context.new(@website)
+    tag = MiniTest::Mock.new
+    tag.expect(:call, 'value', ['mytag', {'opt' => 'val'}, 'body', context])
+    @website.ext.tag = tag
+
+    assert_equal('value', context.tag('mytag', {'opt' => 'val'}, 'body'))
+    tag.verify
+  end
+
+end

data/test/webgen/test_core_ext.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/core_ext'
+
+class TestCoreExtensions < MiniTest::Unit::TestCase
+
+  def test_webgen_require
+    assert_raises(Webgen::LoadError) { webgen_require('unknown_library_here') }
+    webgen_require('webgen/core_ext') rescue flunk
+  end
+
+  def test_hash_symbolize_keys!
+    h = {'a' => 'a', :b => 'b', 5 => 5}.symbolize_keys
+    assert_equal('a', h[:a])
+    assert_equal('b', h[:b])
+    assert_equal(5, h[5])
+  end
+
+end

data/test/webgen/test_destination.rb

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/destination'
+
+class Webgen::Destination::MyDestination
+
+  def initialize(website); end
+
+end
+
+class TestDestination < MiniTest::Unit::TestCase
+
+  def setup
+    @website = MiniTest::Mock.new
+    @dest = Webgen::Destination.new(@website)
+  end
+
+  def test_register
+    @dest.register('Webgen::Destination::MyDestination')
+    assert(@dest.registered?('my_destination'))
+
+    @dest.register('MyDestination')
+    assert(@dest.registered?('my_destination'))
+
+    @dest.register('MyDestination', :name => 'test')
+    assert(@dest.registered?('test'))
+
+    assert_raises(ArgumentError) { @dest.register('doit') { "nothing" } }
+  end
+
+  def test_instance
+    @dest.register('MyDestination')
+
+    @website.expect(:config, {'destination' => 'unknown'})
+    assert_raises(Webgen::Error) { @dest.instance_eval { instance } }
+    @website.verify
+
+    @website.expect(:config, {'destination' => 'my_destination'})
+    assert_kind_of(Webgen::Destination::MyDestination, @dest.instance_eval { instance })
+    @website.verify
+
+    @website.expect(:config, {'destination' => 'unknown'})
+    @dest.instance_eval { instance } # nothing should be raised
+    @website.verify
+  end
+
+end

data/test/webgen/test_error.rb

@@ -0,0 +1,121 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/error'
+
+class TestError < MiniTest::Unit::TestCase
+
+  def test_all
+    e = Webgen::Error.new("test")
+    assert_match(/Error:/, e.message)
+
+    e = Webgen::Error.new("test", 'location')
+    assert_equal('location', e.location)
+    assert_match(/Error at location:/, e.message)
+
+    e = Webgen::Error.new("test", 'location', '/path')
+    assert_equal('location', e.location)
+    assert_equal('/path', e.path)
+    assert_match(/Error at location while working on <\/path>:/, e.message)
+    e.path = 5
+    assert_match(/Error at location while working on <5>:/, e.message)
+
+    e = Webgen::Error.new(Exception.new("test"))
+    assert_match(/Error:.*test/m, e.message)
+  end
+
+  def test_class_error_line
+    begin
+      eval("5 =")
+    rescue SyntaxError => e
+      assert_equal(1, Webgen::Error.error_line(e))
+    end
+
+    begin
+      eval("x = 5\n raise 'hallo'", binding, __FILE__, 1)
+    rescue
+      assert_equal(2, Webgen::Error.error_line($!))
+    end
+  end
+
+  def test_class_error_file
+    begin
+      eval("5 =")
+    rescue SyntaxError => e
+      assert_equal('(eval)', Webgen::Error.error_file(e))
+    end
+
+    begin
+      eval("raise 'hallo'", binding, 'myfile', 1)
+    rescue Exception => e
+      assert_equal('myfile', Webgen::Error.error_file(e))
+    end
+  end
+
+end
+
+class TestNodeCreationError < MiniTest::Unit::TestCase
+
+  def test_all
+    e = Webgen::NodeCreationError.new("test")
+    assert_match(/Error while creating a node:/, e.message)
+    e.path = 5
+    assert_match(/Error while creating a node from <5>:/, e.message)
+  end
+
+end
+
+class TestRenderError < MiniTest::Unit::TestCase
+
+  def test_all
+    e = Webgen::RenderError.new("test", 'location', '/path', '/error')
+    assert_equal("/error", e.error_path)
+    assert_match(/Error at location in <\/error> while rendering <\/path>/, e.message)
+    e.path = 5
+    assert_match(/Error at location in <\/error> while rendering <5>:/, e.message)
+
+    e = Webgen::RenderError.new('test', 'location', '/path', '/error', 5)
+    assert_equal("/error", e.error_path)
+    assert_match(/Error at location in <\/error:~5> while rendering <\/path>/, e.message)
+
+    begin
+      eval("5 =")
+    rescue SyntaxError
+      e = Webgen::RenderError.new($!, 'location', '/path', '/error')
+      assert_equal("/error", e.error_path)
+      assert_match(/Error at location in <\/error:~1> while rendering <\/path>/, e.message)
+    end
+  end
+
+end
+
+class TestLoadError < MiniTest::Unit::TestCase
+
+  def test_all
+    e = Webgen::LoadError.new(Exception.new("something"), 'location', '/path')
+    assert_nil(e.library)
+    assert_nil(e.gem)
+    assert_match(/Error at location while working on <\/path>:.*something/m, e.message)
+
+    e = Webgen::LoadError.new("test", 'location', '/path')
+    assert_equal("test", e.library)
+    assert_nil(e.gem)
+    assert_match(/Error at location while working on <\/path>:.*The needed library 'test' is missing/m, e.message)
+
+    e = Webgen::LoadError.new("test", 'location', '/path', 'gem')
+    assert_equal("test", e.library)
+    assert_equal('gem', e.gem)
+    assert_match(/Error at location while working on <\/path>:.*The needed library 'test' is missing.*gem install gem/m, e.message)
+  end
+
+end
+
+class TestCommandNotFoundError < MiniTest::Unit::TestCase
+
+  def test_all
+    e = Webgen::CommandNotFoundError.new("test", 'location', '/path')
+    assert_equal("test", e.cmd)
+    assert_match(/Error at location while working on <\/path>:.*The needed command 'test' is missing/m, e.message)
+  end
+
+end

data/test/webgen/test_extension_manager.rb

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/extension_manager'
+
+class DummyExtensionManager
+
+  include Webgen::ExtensionManager
+
+  def register(name, value)
+    @extensions[name.to_sym] = OpenStruct.new(:object => value)
+  end
+
+end
+
+class TestExtensionManager < MiniTest::Unit::TestCase
+
+  def setup
+    @dummy = DummyExtensionManager.new
+  end
+
+  def test_registered_extensions
+    assert_kind_of(Hash, @dummy.registered_extensions)
+    assert_empty(@dummy.registered_extensions)
+    @dummy.register('key', 'value')
+    assert(@dummy.registered_extensions.has_key?(:key))
+  end
+
+  def test_registered
+    refute(@dummy.registered?('key'))
+    @dummy.register('key', 'value')
+    assert(@dummy.registered?('key'))
+  end
+
+  def test_normalize_class_name
+    klass, name = @dummy.send(:normalize_class_name, "Klass", false)
+    assert_equal("DummyExtensionManager::Klass", klass)
+    assert_equal("Klass", name)
+    klass, name = @dummy.send(:normalize_class_name, "MyKlass", false)
+    assert_equal("DummyExtensionManager::MyKlass", klass)
+    assert_equal("MyKlass", name)
+    klass, name = @dummy.send(:normalize_class_name, "My::Klass", false)
+    assert_equal("My::Klass", klass)
+    assert_equal("Klass", name)
+    klass, name = @dummy.send(:normalize_class_name, "klass", false)
+    assert_equal("DummyExtensionManager::klass", klass)
+    assert_equal("klass", name)
+  end
+
+  def test_do_register
+    @dummy.send(:do_register, "Klass")
+    assert_equal('DummyExtensionManager::Klass', @dummy.send(:ext_data, 'klass').object)
+    @dummy.send(:do_register, "Test::Klass", :name => 'test')
+    assert_equal('Test::Klass',  @dummy.send(:ext_data, :test).object)
+    @dummy.send(:do_register, DummyExtensionManager, :name => 'test')
+    assert_equal(DummyExtensionManager,  @dummy.send(:ext_data, :test).object)
+  end
+
+  def test_extension
+    @dummy.register('key', 'DummyExtensionManager')
+    assert_equal(DummyExtensionManager, @dummy.send(:extension, "key"))
+    assert_raises(Webgen::Error) { @dummy.send(:extension, "unknown") }
+  end
+
+  def test_resolve_class
+    assert_equal(DummyExtensionManager, @dummy.send(:resolve_class, DummyExtensionManager))
+    assert_equal(DummyExtensionManager, @dummy.send(:resolve_class, 'DummyExtensionManager'))
+  end
+
+end

data/test/webgen/test_item_tracker.rb

@@ -0,0 +1,106 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/item_tracker'
+require 'webgen/blackboard'
+
+class Webgen::ItemTracker::Sample
+
+  def initialize(website) #:nodoc:
+    @website = website
+  end
+
+  def item_id(data) #:nodoc:
+    data
+  end
+
+  def item_data(data) #:nodoc:
+    'alcn' + TestItemTracker::Data[data].to_s
+  end
+
+  def changed?(iid, old_data) #:nodoc:
+    'alcn' + TestItemTracker::Data[iid].to_s != old_data
+  end
+
+  def node_referenced?(iid, _, node_alcn)
+    iid == node_alcn
+  end
+
+end
+
+class TestItemTracker < MiniTest::Unit::TestCase
+
+  Data = {'/alcn' => 'mydata'}
+
+  def test_functionality
+    # Needed mock objects
+    website = MiniTest::Mock.new
+    website.expect(:blackboard, blackboard = Webgen::Blackboard.new)
+    website.expect(:cache, cache = {})
+    node = MiniTest::Mock.new
+    node.expect(:alcn, '/alcn')
+    node.expect(:!, false)
+    node.expect(:hash, 12345)
+    other = MiniTest::Mock.new
+    other.expect(:alcn, '/other')
+    other.expect(:!, false)
+    other.expect(:hash, 12346)
+    website.expect(:tree, {'/alcn' => node, '/other' => other})
+
+    tracker = Webgen::ItemTracker.new(website)
+    tracker.register('Sample')
+    tracker.add(node, :sample, '/alcn')
+
+    # Node should be changed because no cache data is available
+    assert(tracker.node_changed?(node))
+
+    # Node should still be changed after it gets written
+    blackboard.dispatch_msg(:after_node_written, node)
+    assert(tracker.node_changed?(node))
+
+    Data['/alcn'] = 'other'
+
+    # Node should still be changed after all nodes are written because Data changed
+    blackboard.dispatch_msg(:after_all_nodes_written)
+    blackboard.dispatch_msg(:before_all_nodes_written)
+    assert(tracker.node_changed?(node))
+
+    # Node should not be changed anymore
+    blackboard.dispatch_msg(:after_node_written, node)
+    blackboard.dispatch_msg(:after_all_nodes_written)
+    blackboard.dispatch_msg(:before_all_nodes_written)
+    refute(tracker.node_changed?(node))
+
+    # Test the initial loading of the cache data
+    cache[:item_tracker_data] = {
+      :node_dependencies => {'/alcn' => [[:sample, '/alcn']], 'alcn' => ['data']},
+      :item_data => {[:sample, '/alcn'] => 'alcnother', [:sample, 'other'] => 'alcnother'}
+    }
+    blackboard.dispatch_msg(:website_initialized)
+    assert_equal(cache[:item_tracker_data], tracker.instance_variable_get(:@cached))
+
+    # Node should not be changed because of cache data
+    refute(tracker.node_changed?(node))
+
+    # Test the final writing of the cache data
+    blackboard.dispatch_msg(:after_node_written, node)      # needs to be done again because
+    blackboard.dispatch_msg(:after_all_nodes_written) # of :website_initialized above
+    blackboard.dispatch_msg(:website_generated)
+    expected = {
+      :node_dependencies => {'/alcn' => Set.new([[:sample, '/alcn']])},
+      :item_data => {[:sample, '/alcn'] => 'alcnother'}
+    }
+    assert_equal(expected, cache[:item_tracker_data])
+
+    # Test whether the node is referenced
+    tracker.add(other, :sample, '/alcn')
+    blackboard.dispatch_msg(:after_node_written, other)
+    blackboard.dispatch_msg(:after_all_nodes_written)
+
+    assert(tracker.node_referenced?(node))
+
+    website.verify
+    node.verify
+  end
+
+end