thinreports 0.7.7 → 0.8.0

data/test/unit/core/shape/basic/test_internal.rb

@@ -1,58 +1,61 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Basic::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::Basic::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Basic = ThinReports::Core::Shape::Basic
-  
+  Basic = Thinreports::Core::Shape::Basic
+
   def create_internal(format_config = {})
-    Basic::Internal.new(flexmock('parent'),
-                         Basic::Format.new(format_config))
+    report = Thinreports::Report.new layout: data_file('layout_text1')
+    parent = report.start_new_page
+
+    Basic::Internal.new report.page, Basic::Format.new(format_config)
   end
-  
+
   def test_id_should_operate_as_delegator_of_format
     basic = create_internal('id' => 'basic-id')
     assert_same basic.id, basic.format.id
   end
-  
+
   def test_svg_tag_should_operate_as_delegator_of_format
     basic = create_internal('svg' => {'tag' => 'rect'})
     assert_same basic.svg_tag, basic.format.svg_tag
   end
-  
+
   def test_type_should_operate_as_delegator_of_format
     basic = create_internal('type' => 's-ellipse')
     assert_same basic.type, basic.format.type
   end
-  
+
   def test_style_should_return_instance_of_StyleGraphic
-    assert_instance_of ThinReports::Core::Shape::Style::Graphic,
+    assert_instance_of Thinreports::Core::Shape::Style::Graphic,
                        create_internal.style
   end
-  
+
   def test_type_of_asker_should_already_return_true_when_the_specified_type_is_basic
     assert_equal create_internal.type_of?(:basic), true
   end
-  
+
   def test_type_of_asker_should_return_true_when_the_specified_type_equal_self_type_name
     result = []
-    
+
     result << create_internal('type' => 's-rect').type_of?(:rect)
     result << create_internal('type' => 's-ellipse').type_of?(:ellipse)
     result << create_internal('type' => 's-line').type_of?(:line)
     result << create_internal('type' => 's-image').type_of?(:image)
-    
+
     assert_equal result.all?, true
   end
 
   def test_identifier
-    basic = create_internal('id' => 'basic-id')
-    assert_equal basic.identifier, 'basic-id'
+    basic = create_internal 'id' => 'basic-id'
+
+    assert_equal 'basic-id', basic.identifier
 
-    flexmock(basic.style).should_receive(:identifier => 'style-identifier')
+    basic.style.stubs(identifier: 'style-identifier')
     assert_equal basic.identifier, 'basic-idstyle-identifier'
   end
 end

data/test/unit/core/shape/image_block/test_format.rb

@@ -1,9 +1,9 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::ImageBlock::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::ImageBlock::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
   
   TEST_IMAGE_BLOCK_FORMAT = {
     "type" => "s-iblock",
@@ -48,11 +48,11 @@ class ThinReports::Core::Shape::ImageBlock::TestFormat < MiniTest::Unit::TestCas
   end
   
   def build_format
-    ThinReports::Core::Shape::ImageBlock::Format.build(TEST_IMAGE_BLOCK_FORMAT)
+    Thinreports::Core::Shape::ImageBlock::Format.build(TEST_IMAGE_BLOCK_FORMAT)
   end
   
   def format(data)
-    ThinReports::Core::Shape::ImageBlock::Format.new(data)
+    Thinreports::Core::Shape::ImageBlock::Format.new(data)
   end
 
 end

data/test/unit/core/shape/image_block/test_interface.rb

@@ -1,23 +1,24 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::ImageBlock::TestInterface < Minitest::Test
+  include Thinreports::TestHelper
+
+  ImageBlock = Thinreports::Core::Shape::ImageBlock
 
-class ThinReports::Core::Shape::ImageBlock::TestInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  ImageBlock = ThinReports::Core::Shape::ImageBlock
-  
   def setup
-    @interface = ImageBlock::Interface.new(flexmock('parent'),
-                                           ImageBlock::Format.new({}))
+    @report = new_report 'layout_block.tlf'
+    @page = @report.start_new_page
   end
-  
-  def test_src_should_work_the_same_as_value_method
-    @interface.src('/path/to/image.png')
-    assert_equal @interface.src, '/path/to/image.png'
+
+  def test_src
+    @page.item(:image_block1).src('/path/to/image.png')
+    assert_equal '/path/to/image.png', @page.item(:image_block1).src
   end
-  
-  def test_properly_initialized_internal_property
-    assert_instance_of ImageBlock::Internal, @interface.internal
+
+  def test_src=
+    @page.item(:image_block1).src = '/path/to/image.png'
+    assert_equal '/path/to/image.png', @page.item(:image_block1).src
   end
-end
+end

data/test/unit/core/shape/image_block/test_internal.rb

@@ -1,28 +1,31 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::ImageBlock::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
+
+  ImageBlock = Thinreports::Core::Shape::ImageBlock
 
-class ThinReports::Core::Shape::ImageBlock::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  ImageBlock = ThinReports::Core::Shape::ImageBlock
-  
   def test_src_should_return_the_same_value_as_value_method
-    internal = init_internal
+    internal = create_internal
     internal.write_value('/path/to/image.png')
-    
+
     assert_same internal.src, internal.read_value
   end
-  
+
   def test_type_of_asker_should_return_true_when_iblock_value_is_given
-    assert_equal init_internal.type_of?(:iblock), true
+    assert_equal create_internal.type_of?(:iblock), true
   end
-  
+
   def test_type_of_asker_should_return_true_when_block_value_is_given
-    assert_equal init_internal.type_of?(:block), true
+    assert_equal create_internal.type_of?(:block), true
   end
-  
-  def init_internal
-    ImageBlock::Internal.new(flexmock('parent'), ImageBlock::Format.new({}))
+
+  def create_internal
+    report = new_report 'layout_text1'
+    parent = report.start_new_page
+
+    ImageBlock::Internal.new parent, ImageBlock::Format.new({})
   end
-end
+end

data/test/unit/core/shape/list/test_configuration.rb

@@ -1,31 +1,44 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::List::TestConfiguration < Minitest::Test
+  include Thinreports::TestHelper
+
+  List = Thinreports::Core::Shape::List
 
-class ThinReports::Core::Shape::List::TestConfiguration < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  List = ThinReports::Core::Shape::List
-  
   def setup
-    @events = flexmock('events')
-    @store  = flexmock('store')
+    @events = mock('events')
+    @store  = mock('store')
     @config = List::Configuration.new
-  end  
-  
+  end
+
   def test_use_stores
-    flexmock(List::Store).should_receive(:init).with(::Hash).once
-    
-    @config.use_stores(:a => 0, :b => 0)
+    List::Store.expects(:init).once
+
+    @config.use_stores(a: 0, b: 0)
   end
-  
+
+  def test_events
+    assert_instance_of List::Events, @config.events
+
+    out, err = capture_io do
+      @config.events
+    end
+    assert_includes err, '[DEPRECATION]'
+  end
+
+  def test_internal_events
+    assert_same @config.events, @config.internal_events
+  end
+
   def test_store
-    flexmock(List::Store).should_receive(:init => @store)
-    
-    @config.use_stores(:a => 0, :b => 0)
+    List::Store.expects(:init).returns(@store)
+
+    @config.use_stores(a: 0, b: 0)
     assert_same @config.store, @store
   end
-  
+
   def test_store_return_nil_when_uninitialized_yet
     assert_nil @config.store
   end
@@ -33,25 +46,24 @@ class ThinReports::Core::Shape::List::TestConfiguration < MiniTest::Unit::TestCa
   def test_type
     assert_equal @config.type, List::TYPE_NAME
   end
-  
+
   def test_copy
-    copied_store = flexmock('copied store')
-    
-    flexmock(@store, :copy => copied_store)
-    flexmock(List::Store).should_receive(:init => @store)
-
-    copied_events = flexmock('copied events')
-    
-    flexmock(@events, :copy => copied_events)
-    flexmock(List::Events).should_receive(:new => @events)
-    
+    copied_store = mock('copied store')
+
+    @store.stubs(copy: copied_store)
+    List::Store.expects(:init).returns(@store)
+
+    copied_events = mock('copied events')
+
+    @events.stubs(copy: copied_events)
+    List::Events.expects(:new).returns(@events)
+
     @config = List::Configuration.new
-    @config.use_stores(:a => 1)
-    
+    @config.use_stores(a: 1)
+
     copied_config = @config.copy
-    
+
     assert_same copied_config.events, copied_events
     assert_same copied_config.store, copied_store
   end
 end
-

data/test/unit/core/shape/list/test_events.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::List::TestEvents < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::List::TestEvents < Minitest::Test
+  include Thinreports::TestHelper
   
-  List = ThinReports::Core::Shape::List
+  List = Thinreports::Core::Shape::List
   
   def setup
     @events = List::Events.new
@@ -13,19 +13,19 @@ class ThinReports::Core::Shape::List::TestEvents < MiniTest::Unit::TestCase
   
   def test_page_footer_insert_event_should_be_able_to_be_used
     @events.send(:verify_event_type, :page_footer_insert)
-  rescue ThinReports::Errors::UnknownEventType
+  rescue Thinreports::Errors::UnknownEventType
     flunk ':page_footer_insert cannot be used.'
   end
   
   def test_footer_insert_event_should_be_able_to_be_used
     @events.send(:verify_event_type, :footer_insert)
-  rescue ThinReports::Errors::UnknownEventType
+  rescue Thinreports::Errors::UnknownEventType
     flunk ':footer_insert cannot be used.'
   end
   
   def test_page_finalize_event_should_be_able_to_be_used
     @events.send(:verify_event_type, :page_finalize)
-  rescue ThinReports::Errors::UnknownEventType
+  rescue Thinreports::Errors::UnknownEventType
     flunk ':page_finalize cannot be used.'
   end
   

data/test/unit/core/shape/list/test_format.rb

@@ -1,10 +1,10 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::List::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::List::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   TEST_LIST_FORMAT = {
     "type" => "s-list",
     "id" => "List",
@@ -23,32 +23,30 @@ class ThinReports::Core::Shape::List::TestFormat < MiniTest::Unit::TestCase
       "attrs" => {}
     }
   }
-  
-  List = ThinReports::Core::Shape::List
-  
+
+  List = Thinreports::Core::Shape::List
+
   def test_build_when_all_sections_enabled
-    flexmock(List::SectionFormat).
-        should_receive(:build).times(4).and_return({})
-    
+    List::SectionFormat.expects(:build).returns({}).times(4)
+
     begin
       format = build_format
     rescue => e
       flunk exception_details(e, 'Building failed.')
     end
-    
+
     assert_equal format.sections.size, 4
     [:detail, :header, :footer, :page_footer].each do |sec|
       assert_includes format.sections.keys, sec
     end
   end
-  
+
   def test_build_when_page_footer_and_footer_disabled
-    flexmock(List::SectionFormat).
-        should_receive(:build).times(2).and_return({})
-    
+    List::SectionFormat.expects(:build).returns({}).times(2)
+
     format = build_format('page-footer-enabled' => 'false',
                           'footer-enabled'      => 'false')
-    
+
     assert_equal format.sections.size, 2
     [:detail, :header].each do |sec|
       assert_includes format.sections.keys, sec
@@ -57,14 +55,14 @@ class ThinReports::Core::Shape::List::TestFormat < MiniTest::Unit::TestCase
 
   def test_config_readers
     format = List::Format.new(TEST_LIST_FORMAT)
-    
+
     assert_equal format.height, 255
     assert_equal format.auto_page_break?, true
     assert_equal format.has_header?, true
     assert_equal format.has_footer?, true
     assert_equal format.has_page_footer?, true
   end
-  
+
   def build_format(data = {})
     List::Format.build(TEST_LIST_FORMAT.merge(data))
   end

data/test/unit/core/shape/list/test_manager.rb

@@ -1,15 +1,15 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::List::TestManager < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::List::TestManager < Minitest::Test
+  include Thinreports::TestHelper
   
   # Alias
-  List = ThinReports::Core::Shape::List
+  List = Thinreports::Core::Shape::List
   
   def create_report(&block)
-    create_basic_report('basic_list_layout.tlf', &block)
+    new_report('layout_list.tlf', &block)
   end
   
   def list_manager

data/test/unit/core/shape/list/test_page.rb

@@ -1,75 +1,133 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::List::TestPage < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::List::TestPage < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  List = ThinReports::Core::Shape::List
-  
+  List = Thinreports::Core::Shape::List
+
   def create_report(&block)
-    create_basic_report('basic_list_layout.tlf', &block)
+    new_report('layout_list.tlf', &block)
   end
-  
+
   def create_report_for_checking_dispatched_event(event)
     @target_event  = event
     @is_dispatched = false
-    
+
     create_report do |r|
       r.layout.config.list(:list) do |list|
         list.events.on(event) {|e| @is_dispatched = true }
       end
     end
   end
-  
+
   def assert_dispatched_event
     assert @is_dispatched, "The :#{@target_event} event was not dispatched."
   end
-  
+
+  def test_on_page_finalize_callback
+    report = create_report
+    list = report.list(:list)
+
+    counter = 0
+    callback = -> { counter += 1 }
+
+    list.on_page_finalize(&callback)
+
+    5.times { list.add_row }
+    assert_equal 1, counter
+
+    report.generate
+    assert_equal 2, counter
+  end
+
+  def test_on_page_footer_insert_callback
+    report = create_report
+    list = report.list(:list)
+
+    tester = 0
+    callback = -> footer {
+      assert_instance_of List::SectionInterface, footer
+      assert_equal footer.internal.section_name, :page_footer
+
+      tester += 1
+    }
+
+    list.on_page_footer_insert(&callback)
+
+    5.times { list.add_row }
+    assert_equal 1, tester
+
+    report.generate
+    assert_equal 2, tester
+  end
+
+  def test_on_footer_insert_callback
+    report = create_report
+    list = report.list(:list)
+
+    tester = 0
+    callback = -> footer {
+      assert_instance_of List::SectionInterface, footer
+      assert_equal footer.internal.section_name, :footer
+
+      tester += 1
+    }
+
+    list.on_footer_insert(&callback)
+
+    5.times { list.add_row }
+    assert_equal 0, tester
+
+    report.generate
+    assert_equal 1, tester
+  end
+
   def test_page_finalize_event_should_be_dispatched_when_page_break_is_called
     report = create_report_for_checking_dispatched_event :page_finalize
     report.start_new_page do
       list(:list).page_break
     end
-    
+
     assert_dispatched_event
   end
-  
+
   def test_page_finalize_event_should_be_dispatched_when_list_was_overflowed
     report = create_report_for_checking_dispatched_event :page_finalize
     report.start_new_page do
       6.times { list(:list).add_row }
     end
-    
+
     assert_dispatched_event
   end
-  
+
   def test_page_finalize_event_should_be_dispatched_when_a_new_page_is_created
     report = create_report_for_checking_dispatched_event :page_finalize
     report.start_new_page do
       list(:list).add_row
     end
     report.start_new_page
-    
+
     assert_dispatched_event
   end
-  
+
   def test_page_finalize_event_should_be_dispatched_when_report_is_finalized
     report = create_report_for_checking_dispatched_event :page_finalize
     report.start_new_page do
       list(:list).add_row
     end
     report.finalize
-    
+
     assert_dispatched_event
   end
-  
+
   def test_copy_should_properly_work_when_list_has_not_header
-    report = create_basic_report('basic_list_noheader_layout.tlf')
-    
+    report = new_report('layout_list_noheader.tlf')
+
     10.times {|t| report.list.add_row }
   rescue => e
     flunk exception_details(e, 'Not worked when list has not header')
   end
-end
+end