thinreports 0.6.0.pre3

data/test/unit/generator/pdf/document/test_parse_color.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::Pdf::TestParseColor < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  class TestColorParser
+    include ThinReports::Generator::Pdf::ParseColor
+  end
+  
+  def setup
+    @parser = TestColorParser.new
+  end
+  
+  def test_parse_color_with_hexcolor
+    assert_equal @parser.parse_color('#ff0000'), 'ff0000'
+    assert_equal @parser.parse_color('000000'), '000000'
+  end
+  
+  def test_parse_color_with_colorname
+    assert_equal @parser.parse_color('red'), 'ff0000'
+  end
+  
+  def test_parse_color_with_colorname_raise_when_unknown_name_given
+    assert_raises ThinReports::Errors::UnsupportedColorName do
+      @parser.parse_color('whitesmoke')
+    end
+  end
+end

data/test/unit/generator/test_base.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::TestBase < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Generator = ThinReports::Generator
+  
+  class FooHoge < Generator::Base; end
+  
+  def test_subcclasses_are_registered_as_generator_when_inherited
+    assert_same FooHoge, Generator.registry.delete(:foohoge)
+  end
+  
+  def test_initialize_finalize_given_the_report
+    report = flexmock('report').
+               should_receive(:finalize).once.
+               should_receive(:internal).once.mock
+    
+    Generator::Base.new(report)
+  end
+  
+  def test_generate_is_abstract_method
+    assert_raises NotImplementedError do
+      new_generator.generate
+    end
+  end
+  
+  def test_generate_file_is_abstract_method
+    assert_raises NotImplementedError do
+      new_generator.generate_file('output.pdf')
+    end
+  end
+  
+  def test_default_layout
+    generator = new_generator
+    flexmock(generator.report).
+      should_receive(:default_layout).and_return(flexmock('default_layout')).once
+    
+    assert_equal generator.default_layout.flexmock_name, 'default_layout'
+  end
+  
+  def new_generator
+    report = flexmock('report').
+              should_receive(:finalize).
+              should_receive(:internal).and_return(flexmock('report_internal')).mock
+    Generator::Base.new(report)
+  end
+end

data/test/unit/helper.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+begin
+  require 'rubygems'
+  require 'minitest/unit'
+  require 'minitest/spec'
+  require 'flexmock'
+rescue LoadError => e
+  $stderr.puts 'To run the unit tests, you need minitest and flexmock.'
+  raise e
+end
+
+# Run a test automaticaly
+MiniTest::Unit.autorun
+
+# Load misc
+require 'digest/sha1'
+
+module ThinReports::TestHelpers
+  include FlexMock::TestCase
+  
+  def clean_whitespaces(str)
+    str.gsub(/^\s*|\n\s*/, '')
+  end
+  
+  def skip_if_ruby19
+    if RUBY_VERSION > '1.9'
+      skip('This test is not required more than Ruby 1.9.')
+    end
+  end
+  
+  def skip_if_ruby18
+    if RUBY_VERSION < '1.9'
+      skip('This test is not required Ruby 1.8 below.')
+    end
+  end
+end

data/test/unit/layout/test_base.rb

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Layout::TestBase < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Layout = ThinReports::Layout::Base
+  
+  def test_load_format_raise_error_when_file_not_found
+    assert_raises ThinReports::Errors::LayoutFileNotFound do
+      Layout.load_format('dummy.tlf')
+    end
+  end
+  
+  def test_load_format
+    flexmock(File).should_receive(:exists? => true).once
+    flexmock(ThinReports::Layout::Format).should_receive(:build).once
+    
+    Layout.load_format('sample.tlf')
+  end
+  
+  def test_load_format_when_omit_the_file_extension
+    specified_name = 'sample'
+    resolved_name  = 'sample.tlf'
+    
+    flexmock(File).
+      should_receive(:exists?).with(resolved_name).and_return(true).once
+    flexmock(ThinReports::Layout::Format).should_receive(:build).once
+    
+    Layout.load_format(specified_name)
+  end
+  
+  def test_Page_when_not_defined_PageHelpers
+    assert_same Layout.Page, ThinReports::Core::Page
+  end
+  
+  def test_Page_when_defined_PageHelpers
+    Layout.send(:PageHelpers, &proc{})
+    
+    refute_same Layout.Page, ThinReports::Core::Page
+    
+    # Teardown
+    ThinReports::Layout::Base.send(:remove_const, :Page)
+  end
+  
+  def test_PageHelpers
+    Layout.send(:PageHelpers) do
+      def foo
+        'foo'
+      end
+    end
+    
+    assert_same Layout::Page.superclass, ThinReports::Core::Page
+    assert Layout::Page.method_defined?(:foo)
+    
+    # Teardown
+    ThinReports::Layout::Base.send(:remove_const, :Page)
+  end
+  
+  def test_initialize_with_specified_id
+    layout = init_layout(:id => :foo)
+    assert_equal layout.id, :foo
+  end
+  
+  def test_default?
+    assert_equal init_layout.default?, true
+    assert_equal init_layout(:id => :foo).default?, false
+  end
+  
+  def test_config
+    layout = init_layout
+    assert_instance_of ThinReports::Layout::Configuration, layout.config
+  end
+  
+  def test_init_new_page
+    parent = flexmock('parent')
+    layout = init_layout
+    
+    # Should call ThinReports::Core::Page#new with parent and layout.
+    flexmock(ThinReports::Core::Page).
+      should_receive(:new).with(parent, layout).once
+    
+    layout.init_new_page(parent)
+  end
+  
+  def init_layout(options = {})
+    flexmock(Layout).should_receive(:load_format => flexmock('format'))
+    Layout.new('dummy.tlf', options)
+  end
+end

data/test/unit/layout/test_configuration.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Layout::TestConfiguration < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Configuration = ThinReports::Layout::Configuration
+  
+  def setup
+    layout = flexmock('layout')
+    flexmock(layout).should_receive(:format => flexmock('layout_format'))
+    
+    @config = Configuration.new(layout)
+  end
+  
+  def test_undef_items_method
+    refute_respond_to @config, :items
+  end
+  
+  def test_undef_values_method
+    refute_respond_to @config, :values
+  end
+  
+  def test_properly_set_init_item_handler
+    list_format = flexmock('list_format').should_receive(:type => 's-list').once.mock
+    list_config = flexmock('list_config').should_receive(:new).once.mock
+    
+    flexmock(ThinReports::Core::Shape).
+      should_receive(:Configuration).with('s-list').and_return(list_config).once
+      
+    @config.manager.init_item(list_format)
+  end
+  
+  def test_activate
+    list_config = flexmock('list_config').should_receive(:copy).once.mock
+    @config.manager.shapes[:foo] = list_config
+
+    @config.activate(:foo)
+  end
+  
+  def test_activate_return_nil_when_unknown_shape_id
+    assert_nil @config.activate(:unknown)
+  end
+end

data/test/unit/layout/test_format.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Layout::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  TEST_SIMPLE_FORMAT = <<-'EOF'
+  {
+    "built-at":"",
+    "version":"%s",
+    "encoding":"utf-8",
+    "updated-at":"20110528120710",
+    "finger-print":-860627816,
+    "config":{
+      "title":"Sample Layout",
+      "page":{
+        "paper-type":"A4",
+        "width":null,
+        "height":null,
+        "orientation":"portrait",
+        "margin-top":"20",
+        "margin-bottom":"20",
+        "margin-left":"20",
+        "margin-right":"20"
+      },
+      "option":{}
+    },
+    "svg":"<!--SHAPE{\"type\":\"s-rect\",\"id\":\"rect1\"}SHAPE-->
+           <!--SHAPE{\"type\":\"s-image\",\"id\":\"image1\"}SHAPE-->
+           <!--SHAPE{\"type\":\"s-tblock\",\"id\":\"tblock1\"}SHAPE-->
+           <!--SHAPE{\"type\":\"s-tblock\",\"id\":\"tblock2\"}SHAPE-->"
+  }
+  EOF
+  
+  # Alias
+  Shape  = ThinReports::Core::Shape
+  Layout = ThinReports::Layout
+  
+  def test_build_simple_format
+    flexmock(Layout::Format).
+      should_receive(:read_format_file).and_return(create_raw_format).once
+    
+    begin
+      format = Layout::Format.build('dummy.tlf', :force => true)
+    rescue => e
+      flunk exception_details(e, 'Faile to build.')
+    end
+    
+    assert_equal format.shapes.size, 4
+    [:rect1, :image1, :tblock1, :tblock2].each do |shape|
+      assert_includes format.shapes.keys, shape
+    end
+  end
+  
+  def test_identifier_return_the_digest_value
+    flexmock(Layout::Format).
+      should_receive(:read_format_file).and_return(create_raw_format).once  
+    
+    format = Layout::Format.build('dummy.tlf')
+    expect = Digest::SHA1.hexdigest(create_raw_format)
+    
+    assert_equal format.identifier, expect.to_sym
+  end
+  
+  def test_always_return_the_same_result_when_build_in_cached_mode
+    flexmock(Layout::Format).
+      should_receive(:read_format_file).and_return(create_raw_format).times(2)
+    
+    # Run building with in cached mode.
+    # First time, not be cached.
+    result1 = Layout::Format.build('dummy.tlf')
+    
+    # Later, be cached if format is same.
+    result2 = Layout::Format.build('dummy.tlf')
+    
+    assert_same result1, result2
+  end
+  
+  def test_build_raise_when_layout_file_is_incompatible
+    original_rules = Layout::Version::REQUIRED_RULES.dup
+    Layout::Version::REQUIRED_RULES.replace(['== 2.0.0'])
+    
+    flexmock(Layout::Format).
+      should_receive(:read_format_file).and_return(create_raw_format('1.0.0'))
+    
+    assert_raises ThinReports::Errors::IncompatibleLayoutFormat do
+      Layout::Format.build('dummy.tlf')
+    end
+  ensure
+    Layout::Version::REQUIRED_RULES.replace(original_rules)
+  end
+  
+  def setup
+    flexmock(Shape::Tblock::Format).
+      should_receive(:build).and_return {|f| flexmock(:id => f['id']) }
+    flexmock(Shape::Basic::Format).
+      should_receive(:build).and_return {|f| flexmock(:id => f['id']) }
+  end
+  
+  def create_raw_format(version = ThinReports::VERSION)
+    clean_whitespaces(TEST_SIMPLE_FORMAT) % version
+  end
+end

data/test/unit/layout/test_version.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Layout::TestVersion < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Version = ThinReports::Layout::Version
+  
+  def test_comparable_version
+    assert_equal Version.comparable_version('0.6.0'), '0.6.0.99'
+    assert_equal Version.comparable_version('0.6.0.pre'), '0.6.0.1'
+    assert_equal Version.comparable_version('0.6.0.pre2'), '0.6.0.2'
+  end
+  
+  def test_compare_with_simple_rule
+    assert Version.compare('0.6.0', '== 0.6.0')
+    refute Version.compare('0.6.0', '== 0.6.1')
+    
+    refute Version.compare('0.6.0', '> 0.6.0')
+    assert Version.compare('0.6.1', '> 0.6.0')
+    assert Version.compare('0.6.0', '> 0.5.9')
+    assert Version.compare('0.6.0', '> 0.6.0.pre3')
+    assert Version.compare('0.6.0.pre2', '> 0.6.0.pre')
+    
+    assert Version.compare('0.6.0.pre', '< 0.6.0.pre3')
+    
+    assert Version.compare('0.6.0', '>= 0.6.0')
+    assert Version.compare('0.6.0', '<= 0.6.0')
+  end
+  
+  def test_compare_with_multiple_rules
+    assert Version.compare('0.6.0', '> 0.5.0', '< 1.0.0')
+    refute Version.compare('0.6.5', '> 0.6.0', '< 0.6.4')
+  end
+  
+  def test_compatible?
+    required_rules('== 0.6.0.pre3') do
+      assert Version.compatible?('0.6.0.pre3')
+    end
+  end
+  
+  def test_required_rules_inspect
+    required_rules('== 0.6.0.pre3') do
+      assert_equal Version.required_rules_inspect, '(== 0.6.0.pre3)'
+    end
+    required_rules('> 0.6.0', '< 0.7.0') do
+      assert_equal Version.required_rules_inspect, '(> 0.6.0 and < 0.7.0)'
+    end
+  end
+  
+  def required_rules(*rules, &block)
+    original_required_rules = Version::REQUIRED_RULES.dup
+    
+    Version::REQUIRED_RULES.clear
+    rules.each {|rule| Version::REQUIRED_RULES << rule }
+    block.call
+  ensure
+    original_required_rules.each {|rule| Version::REQUIRED_RULES << rule }
+  end
+end

data/test/unit/report/test_base.rb

@@ -0,0 +1,187 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Report::TestBase < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Report = ThinReports::Report
+  
+  def setup
+    @report = Report::Base.new
+  end
+  
+  def test_initialize_with_options
+    flexmock(Report::Internal).
+      should_receive(:new).with(Report::Base, {:layout => 'layout.tlf'}).
+      and_return(flexmock('report_internal')).once
+    
+    report = Report::Base.new(:layout => 'layout.tlf')
+    assert_equal report.internal.flexmock_name, 'report_internal'
+  end
+  
+  def test_use_layout
+    flexmock(@report.internal).
+      should_receive(:register_layout).with('layout.tlf', {:default => true}).
+      and_return(flexmock('layout_config')).once
+    
+    assert_equal @report.use_layout('layout.tlf', :default => true).flexmock_name,
+                 'layout_config'
+  end
+  
+  def test_start_new_page
+    layout = flexmock('layout')
+    layout.should_receive(:init_new_page).once
+    
+    flexmock(@report.internal).
+      should_receive(:load_layout).and_return(layout).once.
+      should_receive(:add_page).and_return(flexmock('new_page')).once
+    
+    assert_equal @report.start_new_page.flexmock_name, 'new_page'
+  end
+  
+  def test_start_new_page_raise_when_no_layout_registered_yet
+    assert_raises ThinReports::Errors::NoRegisteredLayoutFound do
+      @report.start_new_page(:layout => :unknown)
+    end
+  end
+  
+  def test_add_blank_page
+    blank_page = flexmock('blank_page')
+    
+    flexmock(ThinReports::Core::BlankPage).
+      should_receive(:new).and_return(blank_page)
+    
+    flexmock(@report.internal).
+      should_receive(:add_page).with(blank_page)
+    
+    @report.add_blank_page
+  end
+  
+  def test_layout_with_nil_return_the_default_layout
+    flexmock(@report.internal).
+      should_receive(:default_layout).and_return(flexmock('default_layout'))
+    
+    assert_equal @report.layout.flexmock_name, 'default_layout'
+  end
+  
+  def test_layout_with_id_raise_when_no_layout_found
+    assert_raises ThinReports::Errors::UnknownLayoutId do
+      @report.layout(:unknown)
+    end
+  end
+  
+  def test_generate
+    setup_generator do |g|
+      g.should_receive(:generate).and_return('output').once
+    end
+    assert_equal @report.generate(:pdf, {:option => :value}), 'output'
+  end
+  
+  def test_generate_file
+    setup_generator do |g|
+      g.should_receive(:generate_file).with(String).once
+    end
+    @report.generate_file(:pdf, 'output.pdf', {:option => :value})
+  end
+  
+  def test_events
+    flexmock(@report.internal).
+      should_receive(:events).and_return(flexmock('report_events')).once
+    
+    assert_equal @report.events.flexmock_name, 'report_events'
+  end
+  
+  def test_page
+    flexmock(@report.internal).
+      should_receive(:page).and_return(flexmock('current_page')).once
+    
+    assert_equal @report.page.flexmock_name, 'current_page'
+  end
+  
+  def test_page_count
+    assert_equal @report.page_count, 0
+  end
+  
+  def test_finalize
+    @report.finalize
+    assert_equal @report.finalized?, true
+  end
+  
+  def test_Base_create
+    report = Report::Base.create do |r|
+      assert_instance_of Report::Base, r
+    end
+    assert_equal report.finalized?, true
+  end
+  
+  def test_Base_create_raise_when_no_block_given
+    assert_raises ArgumentError do
+      Report::Base.create
+    end
+  end
+  
+  def test_Base_generate
+    flexmock(Report::Base).new_instances.
+      should_receive(:generate).with(:pdf, Hash).once
+    
+    flexmock(Report::Base).
+      should_receive(:create).with(Hash, Proc).
+      and_return(Report::Base.new).once
+    
+    Report::Base.generate(:pdf, :report    => {:layout => 'layout.tlf'},
+                                :generator => {:option => :value}) {}
+  end
+  
+  def test_Base_generate_raise_when_no_block_given
+    assert_raises ArgumentError do
+      Report::Base.generate(:pdf)
+    end
+  end
+  
+  def test_Base_generate_file
+    flexmock(Report::Base).new_instances.
+      should_receive(:generate_file).with(:pdf, String, Hash).once
+    
+    flexmock(Report::Base).
+      should_receive(:create).with(Hash, Proc).
+      and_return(Report::Base.new).once
+    
+    Report::Base.generate_file(:pdf, 'output.pdf', :report    => {:layout => 'layout.tlf'},
+                                                   :generator => {:option => :value}) {}
+  end
+  
+  def test_Base_generate_file_raise_when_no_block_given
+    assert_raises ArgumentError do
+      Report::Base.generate_file(:pdf, 'output.pdf')
+    end
+  end
+  
+  def test_Base_init_generate_params_with_empty_options
+    Report::Base.send(:init_generate_params, options = {}) {}
+    assert_equal options.values_at(:report, :generator), [{}, {}]
+  end
+  
+  def test_Base_init_generate_params_with_configured_options
+    options = {:report    => {:layout => 'layout.tlf'},
+               :generator => {:option => :value}}
+    Report::Base.send(:init_generate_params, options) {}
+    
+    assert_equal options[:report], {:layout => 'layout.tlf'}
+    assert_equal options[:generator], {:option => :value}
+  end
+  
+  def test_Base_init_generate_params_raise_when_no_block_given
+    assert_raises ArgumentError do
+      Report::Base.send(:init_generate_params)
+    end
+  end
+  
+  def setup_generator(&block)
+    block.call(generator = flexmock('generator'))
+    
+    flexmock(ThinReports::Generator).
+      should_receive(:new).with(:pdf, @report, Hash).and_return(generator)
+  end
+end