thinreports 0.7.6 → 0.8.0

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

@@ -1,9 +1,9 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Basic::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Basic::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
 
   TEST_BASIC_FORMAT = {
     "type" => "s-rect",
@@ -28,7 +28,7 @@ class ThinReports::Core::Shape::Basic::TestFormat < MiniTest::Unit::TestCase
   }
 
   # Alias
-  Format = ThinReports::Core::Shape::Basic::Format
+  Format = Thinreports::Core::Shape::Basic::Format
 
   def test_build_basic_format
     build_basic_format

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

@@ -1,118 +1,108 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Basic::TestInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Basic::TestInterface < Minitest::Test
+  include Thinreports::TestHelper
 
   # Alias
-  Basic = ThinReports::Core::Shape::Basic
-  
+  Basic = Thinreports::Core::Shape::Basic
+
   def create_interface(format_config = {})
-    Basic::Interface.new(flexmock('parent'),
-                         Basic::Format.new(format_config))
-  end
-  
-  def setup
-    format = flexmock('format')
-    format.should_receive(:display? => true)
-    
-    @basic = Basic::Interface.new(flexmock('parent'), format)
+    report = Thinreports::Report.new layout: data_file('layout_text1')
+    parent = report.start_new_page
+
+    Basic::Interface.new parent, Basic::Format.new(format_config)
   end
-  
+
   def test_id_should_return_id_with_reference_to_internal
     basic = create_interface('id' => 'foo')
     assert_equal basic.id, basic.internal.id
   end
-  
+
   def test_id_should_return_cloned_id
     basic = create_interface('id' => 'basic-id')
     refute_same basic.id, basic.internal.id
   end
-  
+
   def test_type_should_operate_as_delegator_of_internal
     basic = create_interface('type' => 's-rect')
     assert_same basic.type, basic.internal.type
   end
-  
+
   def test_visible_asker_should_return_result_with_reference_to_style_of_internal
     basic = create_interface('display' => 'false')
     assert_equal basic.visible?, basic.internal.style.visible
   end
-  
+
   def test_visible_should_properly_set_visibility_to_style_of_internal
     basic = create_interface('display' => 'false')
     basic.visible(true)
-    
+
     assert_equal basic.internal.style.visible, true
   end
-  
+
   def test_style_should_operate_as_reader_when_one_argument_is_given
     basic = create_interface('svg' => {'attrs' => {'fill' => '#ff0000'}})
-    
+
     assert_equal basic.style(:fill_color), '#ff0000'
   end
-  
+
   def test_style_should_operate_as_writer_when_two_arguments_are_given
     basic = create_interface
     basic.style(:border_color, '#000000')
-    
+
     assert_equal basic.style(:border_color), '#000000'
   end
-  
+
   def test_style_should_operate_as_writer_for_border_style_when_three_arguments_are_given
     basic = create_interface
     basic.style(:border, 1, '#ffffff')
-    
+
     assert_equal basic.style(:border), [1, '#ffffff']
   end
-  
+
   def test_style_should_return_self_when_two_arguments_are_given
     assert_instance_of Basic::Interface, create_interface.style(:border_width, 1)
   end
-  
+
   def test_style_should_return_self_when_three_arguments_are_given
     assert_instance_of Basic::Interface, create_interface.style(:border, 1, '#000000')
   end
-  
+
   def test_styles_should_properly_set_the_specified_styles_as_Hash
     basic = create_interface
-    basic.styles(:fill_color   => '#ff0000',
-                 :border_color => '#000000',
-                 :border_width => 5,
-                 :visible      => false)
-    
+    basic.styles(fill_color: '#ff0000',
+                 border_color: '#000000',
+                 border_width: 5,
+                 visible: false)
+
     assert_equal [basic.style(:fill_color),
                   basic.style(:border_color),
                   basic.style(:border_width),
                   basic.style(:visible)],
                  ['#ff0000', '#000000', 5, false]
   end
-  
-  def test_styles_should_return_self
-    basic = create_interface
-    assert_instance_of Basic::Interface, basic.styles(:fill => '#ff0000')
-  end
-  
+
   def test_hide_should_properly_set_false_to_visibility
     basic = create_interface
     basic.hide
-    
+
     assert_equal basic.visible?, false
   end
-  
+
   def test_hide_should_return_self
     assert_instance_of Basic::Interface, create_interface.hide
   end
-  
+
   def test_show_should_properly_set_true_to_visibility
     basic = create_interface
     basic.show
-    
+
     assert_equal basic.visible?, true
   end
-  
+
   def test_show_should_return_self
     assert_instance_of Basic::Interface, create_interface.show
   end
-end
+end

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

@@ -1,50 +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
-end
+
+  def test_identifier
+    basic = create_internal 'id' => 'basic-id'
+
+    assert_equal 'basic-id', basic.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,52 +1,69 @@
 # 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
-  
+
+  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
+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
@@ -109,4 +109,14 @@ class ThinReports::Core::Shape::List::TestManager < MiniTest::Unit::TestCase
     
     assert_same list_used_in_event, current_list
   end
+
+  def test_page_count
+    report = create_report
+    assert_equal report.page_count, 0
+
+    report.list(:list).page_break
+    report.list(:list).page_break
+
+    assert_equal report.list(:list).manager.page_count, 2
+  end
 end