thinreports 0.7.7 → 0.8.0

data/test/unit/report/test_events.rb

@@ -1,12 +1,12 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Report::TestEvents < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Report::TestEvents < Minitest::Test
+  include Thinreports::TestHelper
   
   # Alias
-  Report = ThinReports::Report
+  Report = Thinreports::Report
   
   def test_event_types
     events = Report::Events.new

data/test/unit/report/test_internal.rb

@@ -1,31 +1,31 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Report::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Report = ThinReports::Report
-  
+  Report = Thinreports::Report
+
   def report
     Report::Base.new
   end
 
   def sample_layout1
-    data_file('basic_layout1.tlf')
+    data_file('layout_text1.tlf')
   end
 
   def sample_layout2
-    data_file('basic_layout2.tlf')
+    data_file('layout_text2.tlf')
   end
 
   def sample_list_layout
-    data_file('basic_list_layout.tlf')
+    data_file('layout_list.tlf')
   end
 
   def test_layout_specified_in_new_method_should_be_defined_as_default_layout
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     assert_equal internal.default_layout.filename, sample_layout1
   end
 
@@ -35,98 +35,98 @@ class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
 
     assert_equal internal.default_layout.filename, sample_layout1
   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(sample_layout1, default: true)
+
     assert_equal internal.default_layout.filename, sample_layout1
   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: sample_layout1)
+    internal.register_layout(sample_layout2, default: true)
 
     assert_equal internal.default_layout.filename, sample_layout2
   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(sample_layout1, id: :foo)
 
     assert_equal internal.layout_registry[:foo].filename, sample_layout1
   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(sample_layout2, id: :foo)
+
     assert_raises ArgumentError do
-      internal.register_layout(sample_layout1, :id => :foo)
+      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, 
+    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
+      config.list(:list).use_stores foo: 0
+      config.list(:list).use_stores bar: 1000
     end
     pass
   end
-  
+
   def test_add_page_should_finalize_the_current_page
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    page = internal.add_page(ThinReports::Core::Page.new(report, layout))
-    internal.add_page(ThinReports::Core::Page.new(report, layout))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    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(sample_layout1)
-    new_page = ThinReports::Core::Page.new(report, layout)
+    layout = Thinreports::Layout.new(sample_layout1)
+    new_page = Thinreports::Report::Page.new(report, layout)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
 
     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)
-    new_page = ThinReports::Core::Page.new(report, layout)
+    layout = Thinreports::Layout.new(sample_layout1)
+    new_page = Thinreports::Report::Page.new(report, layout)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     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)
-    
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(ThinReports::Core::Page.new(report, layout))
+    layout = Thinreports::Layout.new(sample_layout1)
+
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    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(sample_layout1)
     new_pages = (1..2).inject([]) do |pages, i|
-      pages << ThinReports::Core::Page.new(report, layout)
+      pages << Thinreports::Report::Page.new(report, layout)
     end
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.add_page(new_pages[0])
 
     assert_same internal.page, new_pages[0]
@@ -135,51 +135,51 @@ class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
 
     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)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.events.on(:page_create) {|e| dispatched = true }
-    internal.add_page(ThinReports::Core::Page.new(report, layout))
+    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
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.events.on(:page_create) {|e| dispatched = true }
-    internal.add_page(ThinReports::Core::BlankPage.new)
+    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
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(ThinReports::Core::BlankPage.new(false))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    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
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(ThinReports::Core::BlankPage.new)
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    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 = Report::Internal.new(report, layout: sample_layout1)
     internal.events.on(:generate) {|e| dispatched = true }
     internal.finalize
 
@@ -187,49 +187,48 @@ class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
   end
 
   def test_finalize_should_finalize_the_report
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     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)
-
-    flexmock(internal).
-      should_receive(:finalize_current_page).once
-
+    internal = Report::Internal.new(report, layout: sample_layout1)
     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 => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.finalize
 
     assert internal.finalized?
   end
-  
+
   def test_load_layout_with_String
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    
-    assert_equal internal.load_layout(sample_layout2).filename, 
+    internal = Report::Internal.new(report, layout: sample_layout1)
+
+    assert_equal internal.load_layout(sample_layout2).filename,
                  sample_layout2
   end
-  
+
   def test_load_layout_with_id
     internal = Report::Internal.new(report, {})
-    internal.register_layout(sample_layout1, :id => :sample)
+    internal.register_layout(sample_layout1, id: :sample)
 
-    assert_equal internal.load_layout(:sample).filename, 
+    assert_equal internal.load_layout(:sample).filename,
                  sample_layout1
   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(sample_layout1)
@@ -241,29 +240,28 @@ class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
   def test_load_layout_should_raise_error_when_invalid_value_set
     internal = Report::Internal.new(report, {})
 
-    assert_raises ThinReports::Errors::LayoutFileNotFound do
+    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(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(page = ThinReports::Core::Page.new(report, layout))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    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(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(page = ThinReports::Core::Page.new(report, layout))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal.add_page(page = Thinreports::Report::Page.new(report, layout))
     internal.copy_page
 
     assert_equal internal.page_count, 2
   end
 end
-

data/test/unit/test_config.rb

@@ -1,22 +1,41 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::TestConfig < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::TestConfig < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   def test_generator_of_Configuration_should_return_configuration_of_generator
-    config = ThinReports::Configuration.new
-    assert_instance_of ThinReports::Generator::Configuration, config.generator
+    config = Thinreports::Configuration.new
+    assert_instance_of Thinreports::Generator::Configuration, config.generator
   end
-  
+
   def test_config_should_return_configuration_of_thinreports
-    assert_instance_of ThinReports::Configuration, ThinReports.config
+    assert_instance_of Thinreports::Configuration, Thinreports.config
   end
-  
+
   def test_configure_should_exec_an_given_block_with_config_which_instance_of_Configuration
-    ThinReports.configure do |config|
-      assert_instance_of ThinReports::Configuration, config
+    Thinreports.configure do |config|
+      assert_instance_of Thinreports::Configuration, config
     end
   end
-end
+
+  def test_fallback_fonts
+    config = Thinreports::Configuration.new
+
+    # should be empty by default
+    assert_empty config.fallback_fonts
+
+    config.fallback_fonts = 'Helvetica'
+    assert_equal config.fallback_fonts, ['Helvetica']
+
+    config.fallback_fonts = ['/path/to/font.ttf', 'Courier New']
+    assert_equal config.fallback_fonts, ['/path/to/font.ttf', 'Courier New']
+
+    config.fallback_fonts = []
+    config.fallback_fonts << 'Helvetica'
+    config.fallback_fonts << 'IPAMincho'
+    config.fallback_fonts.unshift 'Times New Roman'
+    assert_equal config.fallback_fonts, ['Times New Roman', 'Helvetica', 'IPAMincho']
+  end
+end

data/test/unit/test_layout.rb

@@ -1,12 +1,12 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::TestLayout < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::TestLayout < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   def test_new
-    flexmock(ThinReports::Layout::Base).should_receive(:new).once
-    ThinReports::Layout.new('layout.tlf')
+    assert_instance_of Thinreports::Layout::Base,
+                       Thinreports::Layout.new(data_file('layout_text1.tlf'))
   end
-end
+end

data/test/unit/test_report.rb

@@ -1,30 +1,18 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::TestReport < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::TestReport < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Report = ThinReports::Report
-  
-  def test_new_should_delegate_to_Base_new
-    flexmock(Report::Base).should_receive(:new).once
-    Report.new
-  end
-  
-  def test_create_should_delegate_to_Base_create
-    flexmock(Report::Base).should_receive(:create).once
-    Report.create
-  end
-  
-  def test_generate_should_delegate_to_Base_generate
-    flexmock(Report::Base).should_receive(:generate).once
-    Report.generate
+  Report = Thinreports::Report
+
+  def test_new
+    assert_instance_of Report::Base, Report.new
   end
-  
-  def test_generate_file_should_delegate_to_Base_generate_file
-    flexmock(Report::Base).should_receive(:generate_file).once
-    Report.generate_file
+
+  def test_create
+    assert_instance_of Report::Base, Report.create {}
   end
-end
+end