thinreports 0.9.1 → 0.11.0

data/test/unit/layout/test_version.rb

@@ -1,95 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Layout::TestVersion < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  Version = Thinreports::Layout::Version
-
-  def test_comparable_version_should_add_99_when_the_given_version_is_not_PRE
-    assert_equal Version.comparable_version('0.7.0'), '0.7.0.99'
-  end
-
-  def test_comparable_version_should_map_pre_to_1_when_the_given_version_is_PRE
-    assert_equal Version.comparable_version('0.6.0.pre'), '0.6.0.1'
-  end
-
-  def test_comparable_version_should_map_pre2_to_2_when_the_given_version_is_PRE2
-    assert_equal Version.comparable_version('0.6.0.pre2'), '0.6.0.2'
-  end
-
-  def test_compare_with_equal_rule_should_return_true_when_the_given_version_is_equal_to_the_version_of_rule
-    assert Version.compare('0.7.0', '== 0.7.0')
-  end
-
-  def test_compare_with_equal_rule_should_return_false_when_the_given_version_is_not_equal_to_the_version_of_rule
-    refute Version.compare('0.6.0.pre3', '== 0.6.0.pre2')
-  end
-
-  def test_compare_with_larger_rule_should_return_true_when_the_given_version_is_larger_than_the_version_of_rule
-    assert Version.compare('0.7.0', '> 0.6.0.pre3')
-  end
-
-  def test_compare_with_larger_rule_should_return_false_when_the_given_version_is_not_larger_than_the_version_of_rule
-    refute Version.compare('0.7.0', '> 0.7.0')
-  end
-
-  def test_compare_with_one_or_more_rule_should_return_true_when_the_given_version_is_equal_to_the_version_of_rule
-    assert Version.compare('0.7.0', '>= 0.7.0')
-  end
-
-  def test_compare_with_one_or_more_rule_should_return_true_when_the_given_version_is_larger_than_the_version_of_rule
-    assert Version.compare('0.7.0', '>= 0.6.0.pre3')
-  end
-
-  def test_compare_with_one_or_more_rule_should_return_false_when_the_give_version_is_not_more_than_the_version_of_rule
-    refute Version.compare('0.6.0.pre3', '>= 0.7.0')
-  end
-
-  def test_compare_with_one_or_less_rule_should_return_true_when_the_given_version_is_equal_to_the_version_of_rule
-    assert Version.compare('0.7.0', '<= 0.7.0')
-  end
-
-  def test_compare_with_one_or_less_rule_should_return_true_when_the_given_version_is_smaller_than_the_version_of_rule
-    assert Version.compare('0.7.0', '<= 0.7.1')
-  end
-
-  def test_compare_with_one_or_less_rule_should_return_false_when_the_given_version_is_not_less_than_the_version_of_rule
-    refute Version.compare('0.7.0', '<= 0.6.0.pre3')
-  end
-
-  def test_inspect_required_rules_should_properly_return_an_inspection_of_rule_when_one_rule_is_given
-    required_rules('== 0.6.0') do
-      assert_equal Version.inspect_required_rules, '(== 0.6.0)'
-    end
-  end
-
-  def test_inspect_required_rules_should_properly_return_an_inspection_of_rules_when_multiple_rules_are_given
-    required_rules('>= 0.6.0.pre3', '< 0.8.0') do
-      assert_equal Version.inspect_required_rules, '(>= 0.6.0.pre3 and < 0.8.0)'
-    end
-  end
-
-  def test_compatible_asker_should_return_true_when_the_given_version_matches_REEQUIRED_RULES
-    required_rules('>= 0.6.0.pre3', '< 0.8.0') do
-      assert Version.compatible?('0.7.0')
-    end
-  end
-
-  def test_compatible_asker_should_return_false_when_the_given_version_does_not_matches_REQUIRED_RULES
-    required_rules('>= 0.6.0.pre3', '< 0.8.0') do
-      refute Version.compatible?('0.8.0')
-    end
-  end
-
-  def required_rules(*rules, &block)
-    original_required_rules = Version::REQUIRED_RULES.dup
-
-    Version::REQUIRED_RULES.replace(rules)
-    block.call
-  ensure
-    Version::REQUIRED_RULES.replace(original_required_rules)
-  end
-end

data/test/unit/report/test_base.rb

@@ -1,262 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Report::TestBase < Minitest::Test
-  include Thinreports::TestHelper
-
-  Report = Thinreports::Report
-
-  def setup
-    @report = Report::Base.new
-    @layout_file = layout_file
-  end
-
-  def test_on_page_create_callback
-    report = Report::Base.new layout: @layout_file.path
-
-    counter = 0
-    callback = -> page {
-      assert_instance_of Report::Page, page
-      counter += 1
-    }
-
-    report.on_page_create(&callback)
-
-    2.times { report.start_new_page }
-    assert_equal counter, 2
-  end
-
-  def test_initialize_should_register_layout_as_default_when_layout_is_specified_as_the_option
-    report = Report::Base.new layout: @layout_file.path
-    assert_equal report.default_layout.filename, @layout_file.path
-  end
-
-  def test_initialize_should_initialize_new_Report_without_default_layout
-    assert_nil @report.default_layout
-  end
-
-  def test_use_layout_should_register_default_layout_when_default_property_is_omitted
-    @report.use_layout(@layout_file.path)
-
-    assert_equal @report.default_layout.filename, @layout_file.path
-  end
-
-  def test_use_layout_should_register_default_layout_when_default_property_is_true
-    @report.use_layout(@layout_file.path, default: true)
-
-    assert_equal @report.default_layout.filename, @layout_file.path
-  end
-
-  def test_start_new_page_should_properly_create_a_new_Page_and_return
-    @report.use_layout(@layout_file.path)
-
-    assert_instance_of Thinreports::Report::Page, @report.start_new_page
-  end
-
-  def test_start_new_page_should_raise_when_the_layout_has_not_been_registered_yet
-    assert_raises Thinreports::Errors::NoRegisteredLayoutFound do
-      @report.start_new_page(layout: :unknown)
-    end
-  end
-
-  def test_start_new_page_should_create_a_new_page_using_a_default_layout
-    @report.use_layout(@layout_file.path, default: true)
-
-    assert_equal @report.start_new_page.layout.filename, @layout_file.path
-  end
-
-  def test_start_new_page_should_create_a_new_page_using_a_layout_with_specified_id
-    @report.use_layout(@layout_file.path, id: :foo)
-
-    assert_equal @report.start_new_page(layout: :foo).layout.filename,
-                 @layout_file.path
-  end
-
-  def test_start_new_page_should_create_a_new_page_using_a_specified_layoutfile
-    new_page = @report.start_new_page(layout: @layout_file.path)
-    assert_equal new_page.layout.filename, @layout_file.path
-  end
-
-  def test_start_new_page_with_count_option
-    @report.use_layout @layout_file.path, default: true
-
-    new_page = @report.start_new_page count: false
-    assert_nil new_page.no
-    assert_equal @report.page_count, 0
-
-    new_page = @report.start_new_page count: true
-    assert_equal new_page.no, 1
-    assert_equal @report.page_count, 1
-
-    new_page = @report.start_new_page
-    assert_equal new_page.no, 2
-    assert_equal @report.page_count, 2
-  end
-
-  def test_add_blank_page_should_properly_create_a_new_blank_page
-    @report.use_layout(@layout_file.path)
-
-    assert_instance_of Thinreports::Report::BlankPage, @report.add_blank_page
-  end
-
-  def test_layout_should_return_the_default_layout_with_no_arguments
-    @report.use_layout(@layout_file.path, default: true)
-
-    assert_equal @report.layout.filename, @layout_file.path
-  end
-
-  def test_layout_should_raise_when_the_specified_layout_is_not_found
-    assert_raises Thinreports::Errors::UnknownLayoutId do
-      @report.layout(:unknown_layout_id)
-    end
-  end
-
-  def test_layout_should_return_the_layout_with_specified_id
-    @report.use_layout(@layout_file.path, id: :foo)
-
-    assert_equal @report.layout(:foo).filename, @layout_file.path
-  end
-
-  def test_generate_with_filename
-    report = Report::Base.new layout: @layout_file.path
-
-    report.generate :pdf, filename: temp_path.join('result1.pdf')
-    report.generate filename: temp_path.join('result2.pdf')
-
-    assert File.exist?(temp_path.join('result1.pdf'))
-    assert File.exist?(temp_path.join('result2.pdf'))
-
-    assert_equal File.read(temp_path.join('result1.pdf')),
-                 File.read(temp_path.join('result2.pdf'))
-  end
-
-  def test_page_should_return_the_current_page
-    @report.use_layout(@layout_file.path)
-    @report.start_new_page
-
-    assert_instance_of Thinreports::Report::Page, @report.page
-  end
-
-  def test_page_count_should_return_total_page_count
-    @report.use_layout(@layout_file.path)
-    2.times { @report.start_new_page }
-
-    assert_equal @report.page_count, 2
-  end
-
-  def test_finalize_should_finalize_report
-    @report.finalize
-    assert_equal @report.finalized?, true
-  end
-
-  def test_finalized_asker_should_return_false_when_report_has_not_been_finalized_yet
-    assert_equal @report.finalized?, false
-  end
-
-  def test_finalized_asker_should_return_true_when_report_is_already_finalized
-    @report.finalize
-    assert_equal @report.finalized?, true
-  end
-
-  def test_list_should_create_new_page_when_page_is_not_created
-    @report.use_layout(@layout_file.path)
-    @report.list
-
-    refute_nil @report.page
-  end
-
-  def test_list_should_create_new_page_when_page_is_finalized
-    @report.tap do |r|
-      r.use_layout(@layout_file.path)
-      r.start_new_page
-      r.page.finalize
-    end
-    @report.list
-
-    assert_equal @report.page.finalized?, false
-  end
-
-  def test_list_should_properly_return_shape_with_the_specified_id
-    @report.use_layout(@layout_file.path)
-
-    assert_equal @report.list.id, 'default'
-  end
-
-  def test_start_page_number
-    assert_equal @report.start_page_number, 1
-    @report.start_page_number_from 10
-    assert_equal @report.start_page_number, 10
-  end
-
-  def test_Base_create_should_finalize_report
-    report = Report::Base.create do |r|
-      assert_instance_of Report::Base, r
-    end
-    assert_equal report.finalized?, true
-  end
-
-  def test_Base_create_should_raise_when_no_block_given
-    assert_raises ArgumentError do
-      Report::Base.create
-    end
-  end
-
-  def test_Base_generate_with_filename
-    Report::Base.generate(:pdf, report: { layout: @layout_file.path },
-                          generator: { filename: temp_path.join('result1.pdf') }) {}
-    Report::Base.generate(report: { layout: @layout_file.path },
-                          generator: { filename: temp_path.join('result2.pdf') }) {}
-
-    assert_equal temp_path.join('result1.pdf').read,
-                 temp_path.join('result2.pdf').read
-  end
-
-  def test_Base_generate_should_raise_when_no_block_given
-    assert_raises ArgumentError do
-      Report::Base.generate(:pdf)
-    end
-  end
-
-  def test_Base_extract_options_should_return_as_report_option_the_value_which_has_report_in_a_key
-    report, _generator = Report::Base.send(:extract_options!, [{report: {layout: 'hoge.tlf'}}])
-    assert_equal report[:layout], 'hoge.tlf'
-  end
-
-  def test_Base_extract_options_should_operate_an_argument_destructively
-    args = [:pdf, 'output.pdf', {report: {layout: 'foo.tlf'}}]
-    Report::Base.send(:extract_options!, args)
-    assert_equal args, [:pdf, 'output.pdf']
-  end
-
-  def test_Base_extract_options_should_include_the_layout_key_in_the_report_option
-    report, _generator = Report::Base.send(:extract_options!, [{layout: 'hoge.tlf'}])
-    assert_equal report[:layout], 'hoge.tlf'
-  end
-
-  def test_Base_extract_options_should_give_priority_to_the_value_of_the_layout_key_over_in_the_report_option
-    report, _generator = Report::Base.send(:extract_options!,
-                                          [{report: {layout: 'foo.tlf'}, layout: 'hoge.tlf'}])
-    assert_equal report[:layout], 'hoge.tlf'
-  end
-
-  def test_Base_extract_options_should_return_as_generator_option_the_value_which_has_generator_in_a_key
-    _report, generator = Report::Base.send(:extract_options!,
-                                          [{generator: {option: 'value'}}])
-    assert_equal generator[:option], 'value'
-  end
-
-  def test_Base_extract_options_should_give_priority_to_the_value_of_other_keys_over_in_the_generator_option
-    _report, generator = Report::Base.send(:extract_options!,
-                                          [{generator: {option: 'value1'}, option: 'value2'}])
-    assert_equal generator[:option], 'value2'
-  end
-
-  def test_Base_extract_options_should_return_all_the_values_except_the_report_option_as_a_generator_option
-    _report, generator = Report::Base.send(:extract_options!,
-                                          [{report: {layout: 'foo.tlf'}, layout: 'hoge.tlf',
-                                            generator_opt1: 'value1', generator_opt2: 'value2'}])
-    assert_equal generator.values_at(:generator_opt1, :generator_opt2),
-                 ['value1', 'value2']
-  end
-end

data/test/unit/report/test_internal.rb

@@ -1,206 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Report::TestInternal < Minitest::Test
-  include Thinreports::TestHelper
-
-  Report = Thinreports::Report
-
-  def setup
-    @layout_file = layout_file
-  end
-
-  def report
-    Report::Base.new
-  end
-
-  def test_layout_specified_in_new_method_should_be_defined_as_default_layout
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    assert_equal internal.default_layout.filename, @layout_file.path
-  end
-
-  def test_register_layout_should_be_set_as_default_layout_when_options_are_omitted
-    internal = Report::Internal.new(report, {})
-    internal.register_layout(@layout_file.path)
-
-    assert_equal internal.default_layout.filename, @layout_file.path
-  end
-
-  def test_register_layout_should_be_set_as_default_layout_when_default_option_is_true
-    internal = Report::Internal.new(report, {})
-    internal.register_layout(@layout_file.path, default: true)
-
-    assert_equal internal.default_layout.filename, @layout_file.path
-  end
-
-  def test_register_layout_should_be_able_to_change_the_default_layout
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.register_layout(@layout_file.path, default: true)
-
-    assert_equal internal.default_layout.filename, @layout_file.path
-  end
-
-  def test_register_layout_should_be_set_as_with_id_when_id_option_is_set
-    internal = Report::Internal.new(report, {})
-    internal.register_layout(@layout_file.path, id: :foo)
-
-    assert_equal internal.layout_registry[:foo].filename, @layout_file.path
-  end
-
-  def test_register_layout_should_raise_an_error_when_id_is_already_registered
-    internal = Report::Internal.new(report, {})
-    internal.register_layout(@layout_file.path, id: :foo)
-
-    assert_raises ArgumentError do
-      internal.register_layout(@layout_file.path, id: :foo)
-    end
-  end
-
-  def test_add_page_should_finalize_the_current_page
-    layout = Thinreports::Layout.new(@layout_file.path)
-
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    page = internal.add_page(Thinreports::Report::Page.new(report, layout))
-    internal.add_page(Thinreports::Report::Page.new(report, layout))
-
-    assert_equal page.finalized?, true
-  end
-
-  def test_add_page_should_return_the_current_page
-    layout = Thinreports::Layout.new(@layout_file.path)
-    new_page = Thinreports::Report::Page.new(report, layout)
-
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-
-    assert_same new_page, internal.add_page(new_page)
-  end
-
-  def test_add_page_should_add_the_initialized_page
-    layout = Thinreports::Layout.new(@layout_file.path)
-    new_page = Thinreports::Report::Page.new(report, layout)
-
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.add_page(new_page)
-
-    assert_same new_page, internal.pages.last
-  end
-
-  def test_add_page_should_count_up_the_total_page_count
-    layout = Thinreports::Layout.new(@layout_file.path)
-
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.add_page(Thinreports::Report::Page.new(report, layout))
-
-    assert_equal internal.page_count, 1
-  end
-
-  def test_add_page_should_switch_to_a_reference_to_the_current_page
-    layout = Thinreports::Layout.new(@layout_file.path)
-    new_pages = (1..2).inject([]) do |pages|
-      pages << Thinreports::Report::Page.new(report, layout)
-    end
-
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.add_page(new_pages[0])
-
-    assert_same internal.page, new_pages[0]
-
-    internal.add_page(new_pages[1])
-
-    assert_same internal.page, new_pages[1]
-  end
-
-  def test_add_blank_page_should_not_count_up_the_total_page_count_when_count_is_disabled
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.add_page(Thinreports::Report::BlankPage.new(false))
-
-    assert_equal internal.page_count, 0
-  end
-
-  def test_add_blank_page_should_count_up_the_total_page_count_when_count_is_enabled
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.add_page(Thinreports::Report::BlankPage.new)
-
-    assert_equal internal.page_count, 1
-  end
-
-  def test_finalize_should_finalize_the_report
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.finalize
-
-    assert internal.finalized?
-  end
-
-  def test_finalize_should_not_work_when_report_is_already_finalized
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.finalize
-
-    # #finalize_current_page must never be called
-    internal.expects(:finalize_current_page).never
-    internal.finalize
-  end
-
-  def test_finalized_should_return_true_when_report_is_already_finalized
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.finalize
-
-    assert internal.finalized?
-  end
-
-  def test_load_layout_with_String
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-
-    assert_equal internal.load_layout(@layout_file.path).filename,
-                 @layout_file.path
-  end
-
-  def test_load_layout_with_id
-    internal = Report::Internal.new(report, {})
-    internal.register_layout(@layout_file.path, id: :sample)
-
-    assert_equal internal.load_layout(:sample).filename,
-                 @layout_file.path
-  end
-
-  def test_load_layout_with_unknown_id
-    internal = Report::Internal.new(report, {})
-    assert_nil internal.load_layout(:unknown)
-  end
-
-  def test_load_layout_should_set_default_layout_when_default_layout_is_nil
-    internal = Report::Internal.new(report, {})
-    internal.load_layout(@layout_file.path)
-
-    assert_equal internal.default_layout.filename,
-                 @layout_file.path
-  end
-
-  def test_load_layout_should_raise_error_when_invalid_value_set
-    internal = Report::Internal.new(report, {})
-
-    assert_raises Thinreports::Errors::LayoutFileNotFound do
-      internal.load_layout('/path/to/unkown.tlf')
-    end
-  end
-
-  def test_copy_page_should_finalize_current_page
-    layout = Thinreports::Layout.new(@layout_file.path)
-
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.add_page(page = Thinreports::Report::Page.new(report, layout))
-    internal.copy_page
-
-    assert page.finalized?
-  end
-
-  def test_copy_page_should_add_the_copied_page
-    layout = Thinreports::Layout.new(@layout_file.path)
-
-    internal = Report::Internal.new(report, layout: @layout_file.path)
-    internal.add_page(Thinreports::Report::Page.new(report, layout))
-    internal.copy_page
-
-    assert_equal internal.page_count, 2
-  end
-end