thinreports 0.8.2 → 0.9.0

data/test/unit/layout/test_version.rb

@@ -4,89 +4,89 @@ 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

data/test/unit/report/test_base.rb

@@ -5,15 +5,15 @@ require 'test_helper'
 class Thinreports::Report::TestBase < Minitest::Test
   include Thinreports::TestHelper
 
-  # Alias
   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: data_file('layout_text1.tlf')
+    report = Report::Base.new layout: @layout_file.path
 
     counter = 0
     callback = -> page {
@@ -28,8 +28,8 @@ class Thinreports::Report::TestBase < Minitest::Test
   end
 
   def test_initialize_should_register_layout_as_default_when_layout_is_specified_as_the_option
-    report = Report::Base.new layout: data_file('layout_text1.tlf')
-    assert_equal report.default_layout.filename, data_file('layout_text1.tlf')
+    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
@@ -37,19 +37,19 @@ class Thinreports::Report::TestBase < Minitest::Test
   end
 
   def test_use_layout_should_register_default_layout_when_default_property_is_omitted
-    @report.use_layout(data_file('layout_text1.tlf'))
+    @report.use_layout(@layout_file.path)
 
-    assert_equal @report.default_layout.filename, data_file('layout_text1.tlf')
+    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(data_file('layout_text2.tlf'), default: true)
+    @report.use_layout(@layout_file.path, default: true)
 
-    assert_equal @report.default_layout.filename, data_file('layout_text2.tlf')
+    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(data_file('layout_text1'))
+    @report.use_layout(@layout_file.path)
 
     assert_instance_of Thinreports::Report::Page, @report.start_new_page
   end
@@ -61,25 +61,25 @@ class Thinreports::Report::TestBase < Minitest::Test
   end
 
   def test_start_new_page_should_create_a_new_page_using_a_default_layout
-    @report.use_layout(data_file('layout_text1.tlf'), default: true)
+    @report.use_layout(@layout_file.path, default: true)
 
-    assert_equal @report.start_new_page.layout.filename, data_file('layout_text1.tlf')
+    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(data_file('layout_text1.tlf'), id: :foo)
+    @report.use_layout(@layout_file.path, id: :foo)
 
     assert_equal @report.start_new_page(layout: :foo).layout.filename,
-                 data_file('layout_text1.tlf')
+                 @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: data_file('layout_text1.tlf'))
-    assert_equal new_page.layout.filename, data_file('layout_text1.tlf')
+    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 data_file('layout_text1.tlf'), default: true
+    @report.use_layout @layout_file.path, default: true
 
     new_page = @report.start_new_page count: false
     assert_nil new_page.no
@@ -95,15 +95,15 @@ class Thinreports::Report::TestBase < Minitest::Test
   end
 
   def test_add_blank_page_should_properly_create_a_new_blank_page
-    @report.use_layout(data_file('layout_text1'))
+    @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(data_file('layout_text1.tlf'), default: true)
+    @report.use_layout(@layout_file.path, default: true)
 
-    assert_equal @report.layout.filename, data_file('layout_text1.tlf')
+    assert_equal @report.layout.filename, @layout_file.path
   end
 
   def test_layout_should_raise_when_the_specified_layout_is_not_found
@@ -113,13 +113,13 @@ class Thinreports::Report::TestBase < Minitest::Test
   end
 
   def test_layout_should_return_the_layout_with_specified_id
-    @report.use_layout(data_file('layout_text2.tlf'), id: :foo)
+    @report.use_layout(@layout_file.path, id: :foo)
 
-    assert_equal @report.layout(:foo).filename, data_file('layout_text2.tlf')
+    assert_equal @report.layout(:foo).filename, @layout_file.path
   end
 
   def test_generate_with_filename
-    report = Report::Base.new layout: data_file('layout_text1.tlf')
+    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')
@@ -131,26 +131,15 @@ class Thinreports::Report::TestBase < Minitest::Test
                  File.read(temp_path.join('result2.pdf'))
   end
 
-  def test_events_should_return_Report_Events
-    assert_instance_of Thinreports::Report::Events, @report.events
-  end
-
-  def test_events_should_deprecated
-    _out, err = capture_io do
-      @report.events
-    end
-    assert_includes err, '[DEPRECATION]'
-  end
-
   def test_page_should_return_the_current_page
-    @report.use_layout(data_file('layout_text1.tlf'))
+    @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(data_file('layout_text1.tlf'))
+    @report.use_layout(@layout_file.path)
     2.times { @report.start_new_page }
 
     assert_equal @report.page_count, 2
@@ -171,27 +160,27 @@ class Thinreports::Report::TestBase < Minitest::Test
   end
 
   def test_list_should_create_new_page_when_page_is_not_created
-    @report.use_layout(data_file('layout_list.tlf'))
-    @report.list(:list)
+    @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(data_file('layout_list.tlf'))
+      r.use_layout(@layout_file.path)
       r.start_new_page
       r.page.finalize
     end
-    @report.list(:list)
+    @report.list
 
     assert_equal @report.page.finalized?, false
   end
 
   def test_list_should_properly_return_shape_with_the_specified_id
-    @report.use_layout(data_file('layout_list.tlf'))
+    @report.use_layout(@layout_file.path)
 
-    assert_equal @report.list(:list).id, 'list'
+    assert_equal @report.list.id, 'default'
   end
 
   def test_start_page_number
@@ -214,11 +203,9 @@ class Thinreports::Report::TestBase < Minitest::Test
   end
 
   def test_Base_generate_with_filename
-    layout_file = data_file 'layout_text1.tlf'
-
-    Report::Base.generate(:pdf, report: { layout: layout_file },
+    Report::Base.generate(:pdf, report: { layout: @layout_file.path },
                           generator: { filename: temp_path.join('result1.pdf') }) {}
-    Report::Base.generate(report: { layout: layout_file },
+    Report::Base.generate(report: { layout: @layout_file.path },
                           generator: { filename: temp_path.join('result2.pdf') }) {}
 
     assert_equal temp_path.join('result1.pdf').read,

data/test/unit/report/test_internal.rb

@@ -5,87 +5,62 @@ require 'test_helper'
 class Thinreports::Report::TestInternal < Minitest::Test
   include Thinreports::TestHelper
 
-  # Alias
   Report = Thinreports::Report
 
-  def report
-    Report::Base.new
-  end
-
-  def sample_layout1
-    data_file('layout_text1.tlf')
+  def setup
+    @layout_file = layout_file
   end
 
-  def sample_layout2
-    data_file('layout_text2.tlf')
-  end
-
-  def sample_list_layout
-    data_file('layout_list.tlf')
+  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: sample_layout1)
-    assert_equal internal.default_layout.filename, sample_layout1
+    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(sample_layout1)
+    internal.register_layout(@layout_file.path)
 
-    assert_equal internal.default_layout.filename, sample_layout1
+    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(sample_layout1, default: true)
+    internal.register_layout(@layout_file.path, default: true)
 
-    assert_equal internal.default_layout.filename, sample_layout1
+    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: sample_layout1)
-    internal.register_layout(sample_layout2, default: true)
+    internal = Report::Internal.new(report, layout: @layout_file.path)
+    internal.register_layout(@layout_file.path, default: true)
 
-    assert_equal internal.default_layout.filename, sample_layout2
+    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(sample_layout1, id: :foo)
+    internal.register_layout(@layout_file.path, id: :foo)
 
-    assert_equal internal.layout_registry[:foo].filename, sample_layout1
+    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(sample_layout2, id: :foo)
+    internal.register_layout(@layout_file.path, id: :foo)
 
     assert_raises ArgumentError do
-      internal.register_layout(sample_layout1, id: :foo)
-    end
-  end
-
-  def test_register_layout_should_return_the_instance_of_LayoutConfiguration
-    internal = Report::Internal.new(report, {})
-
-    assert_instance_of Thinreports::Layout::Configuration,
-                       internal.register_layout(sample_layout1)
-  end
-
-  def test_register_layout_should_be_able_to_set_list_configuration_without_errors
-    internal = Report::Internal.new(report, {})
-    internal.register_layout(sample_list_layout) do |config|
-      config.list(:list).use_stores foo: 0
-      config.list(:list).use_stores bar: 1000
+      internal.register_layout(@layout_file.path, id: :foo)
     end
-    pass
   end
 
   def test_add_page_should_finalize_the_current_page
-    layout = Thinreports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(@layout_file.path)
 
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    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))
 
@@ -93,40 +68,40 @@ class Thinreports::Report::TestInternal < Minitest::Test
   end
 
   def test_add_page_should_return_the_current_page
-    layout = Thinreports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(@layout_file.path)
     new_page = Thinreports::Report::Page.new(report, layout)
 
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    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(sample_layout1)
+    layout = Thinreports::Layout.new(@layout_file.path)
     new_page = Thinreports::Report::Page.new(report, layout)
 
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    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(sample_layout1)
+    layout = Thinreports::Layout.new(@layout_file.path)
 
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    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(sample_layout1)
+    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: sample_layout1)
+    internal = Report::Internal.new(report, layout: @layout_file.path)
     internal.add_page(new_pages[0])
 
     assert_same internal.page, new_pages[0]
@@ -136,60 +111,29 @@ class Thinreports::Report::TestInternal < Minitest::Test
     assert_same internal.page, new_pages[1]
   end
 
-  def test_add_page_should_dispatch_the_event_page_creation
-    dispatched = false
-    layout = Thinreports::Layout.new(sample_layout1)
-
-    internal = Report::Internal.new(report, layout: sample_layout1)
-    internal.events.on(:page_create) { dispatched = true }
-    internal.add_page(Thinreports::Report::Page.new(report, layout))
-
-    assert dispatched
-  end
-
-  def test_add_blank_page_should_not_dispatch_the_event_page_creation
-    dispatched = false
-
-    internal = Report::Internal.new(report, layout: sample_layout1)
-    internal.events.on(:page_create) { dispatched = true }
-    internal.add_page(Thinreports::Report::BlankPage.new)
-
-    refute dispatched
-  end
-
   def test_add_blank_page_should_not_count_up_the_total_page_count_when_count_is_disabled
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    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: sample_layout1)
+    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_dispatch_the_event_report_generation
-    dispatched = false
-
-    internal = Report::Internal.new(report, layout: sample_layout1)
-    internal.events.on(:generate) { dispatched = true }
-    internal.finalize
-
-    assert dispatched
-  end
-
   def test_finalize_should_finalize_the_report
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    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: sample_layout1)
+    internal = Report::Internal.new(report, layout: @layout_file.path)
     internal.finalize
 
     # #finalize_current_page must never be called
@@ -198,25 +142,25 @@ class Thinreports::Report::TestInternal < Minitest::Test
   end
 
   def test_finalized_should_return_true_when_report_is_already_finalized
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    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: sample_layout1)
+    internal = Report::Internal.new(report, layout: @layout_file.path)
 
-    assert_equal internal.load_layout(sample_layout2).filename,
-                 sample_layout2
+    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(sample_layout1, id: :sample)
+    internal.register_layout(@layout_file.path, id: :sample)
 
     assert_equal internal.load_layout(:sample).filename,
-                 sample_layout1
+                 @layout_file.path
   end
 
   def test_load_layout_with_unknown_id
@@ -226,10 +170,10 @@ class Thinreports::Report::TestInternal < Minitest::Test
 
   def test_load_layout_should_set_default_layout_when_default_layout_is_nil
     internal = Report::Internal.new(report, {})
-    internal.load_layout(sample_layout1)
+    internal.load_layout(@layout_file.path)
 
     assert_equal internal.default_layout.filename,
-                 sample_layout1
+                 @layout_file.path
   end
 
   def test_load_layout_should_raise_error_when_invalid_value_set
@@ -241,9 +185,9 @@ class Thinreports::Report::TestInternal < Minitest::Test
   end
 
   def test_copy_page_should_finalize_current_page
-    layout = Thinreports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(@layout_file.path)
 
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal = Report::Internal.new(report, layout: @layout_file.path)
     internal.add_page(page = Thinreports::Report::Page.new(report, layout))
     internal.copy_page
 
@@ -251,9 +195,9 @@ class Thinreports::Report::TestInternal < Minitest::Test
   end
 
   def test_copy_page_should_add_the_copied_page
-    layout = Thinreports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(@layout_file.path)
 
-    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal = Report::Internal.new(report, layout: @layout_file.path)
     internal.add_page(Thinreports::Report::Page.new(report, layout))
     internal.copy_page