thinreports 0.6.0.pre3 → 0.7.0

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

@@ -5,38 +5,46 @@ require 'test/unit/helper'
 class ThinReports::Core::Shape::Basic::TestInternal < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
+  # Alias
   Basic = ThinReports::Core::Shape::Basic
   
-  def setup
-    format = flexmock('format')
-    format.should_receive(:display? => true)
-    
-    @internal = Basic::Internal.new(flexmock('parent'), format)
+  def create_internal(format_config = {})
+    Basic::Internal.new(flexmock('parent'),
+                         Basic::Format.new(format_config))
   end
   
-  def test_visible
-    assert_equal @internal.visible?, true
-    
-    @internal.visible(false)
-    
-    assert_equal @internal.visible?, false
-    assert_equal @internal.format.display?, true
+  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_attr
-    assert_empty @internal.attrs
-    
-    @internal.svg_attr(:fill, 'red')
-    @internal.svg_attr(:stroke, 'black')
-    
-    assert_equal @internal.attrs, {'fill' => 'red', 'stroke' => 'black'}
+  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,
+                       create_internal.style
   end
   
-  def test_type_of?
-    flexmock(@internal.format).should_receive(:type => 's-rect')
+  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 @internal.type_of?(:basic), true
-    assert_equal @internal.type_of?(:rect), true
-    assert_equal @internal.type_of?(:tblock), false
+    assert_equal result.all?, true
   end
 end

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

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::ImageBlock::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  TEST_IMAGE_BLOCK_FORMAT = {
+    "type" => "s-iblock",
+    "id" => "image",
+    "display" => "true",
+    "box" => {
+      "x" => 100.0,
+      "y" => 100.0,
+      "width" => 100.0,
+      "height" => 100.0
+    },
+    "position-x" => "left",
+    "position-y" => "top",
+    "svg" => {
+      "tag" => "image",
+      "attrs" => {
+        "x" => 100.0,
+        "y" => 100.0,
+        "width" => 100.0,
+        "height" => 100.0
+      }
+    }
+  }
+  
+  def test_build
+    build_format
+  rescue => e
+    flunk exception_details(e, 'Building failed.')
+  end
+  
+  def test_box_reader_via_TEST_IMAGE_BLOCK_FORMAT
+    assert_equal format(TEST_IMAGE_BLOCK_FORMAT).box.values_at('x', 'y', 'width', 'height'),
+                 [100.0, 100.0, 100.0, 100.0]
+  end
+  
+  def test_position_x_reader_via_TEST_IMAGE_BLOCK_FORMAT
+    assert_equal format(TEST_IMAGE_BLOCK_FORMAT).position_x, 'left'
+  end
+  
+  def test_position_y_reader_via_TEST_IMAGE_BLOCK_FORMAT
+    assert_equal format(TEST_IMAGE_BLOCK_FORMAT).position_y, 'top'
+  end
+  
+  def build_format
+    ThinReports::Core::Shape::ImageBlock::Format.build(TEST_IMAGE_BLOCK_FORMAT)
+  end
+  
+  def format(data)
+    ThinReports::Core::Shape::ImageBlock::Format.new(data)
+  end
+
+end

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

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+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({}))
+  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'
+  end
+  
+  def test_properly_initialized_internal_property
+    assert_instance_of ImageBlock::Internal, @interface.internal
+  end
+end

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

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+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.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
+  end
+  
+  def test_type_of_asker_should_return_true_when_block_value_is_given
+    assert_equal init_internal.type_of?(:block), true
+  end
+  
+  def init_internal
+    ImageBlock::Internal.new(flexmock('parent'), ImageBlock::Format.new({}))
+  end
+end

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

@@ -11,18 +11,26 @@ class ThinReports::Core::Shape::List::TestEvents < MiniTest::Unit::TestCase
     @events = List::Events.new
   end
   
-  def test_allowed_event_types
-    assert_equal @events.instance_variable_get(:@types),
-                 [:page_footer_insert, :footer_insert]
+  def test_page_footer_insert_event_should_be_able_to_be_used
+    @events.send(:verify_event_type, :page_footer_insert)
+  rescue ThinReports::Errors::UnknownEventType
+    flunk ':page_footer_insert cannot be used.'
   end
   
-  def test_SectionEvent
-    e = List::Events::SectionEvent.new(:section_event,
-                                       :target,
-                                       :store)
-    assert_equal e.type, :section_event
-    assert_equal e.target, :target
-    assert_equal e.section, :target
-    assert_equal e.store, :store
+  def test_footer_insert_event_should_be_able_to_be_used
+    @events.send(:verify_event_type, :footer_insert)
+  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
+    flunk ':page_finalize cannot be used.'
+  end
+  
+  def test_list_property_of_PageEvent_should_equal_to_target_property
+    ev = List::Events::PageEvent.new(:page_finalize, 'list', 'page')
+    assert_same ev.list, ev.target
   end
 end

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

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestManager < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  List = ThinReports::Core::Shape::List
+  
+  def create_report(&block)
+    create_basic_report('basic_list_layout.tlf', &block)
+  end
+  
+  def list_manager
+    report = create_report {|r| r.start_new_page }
+    report.page.list(:list).manager
+  end
+  
+  def test_config_should_return_the_instance_of_ListConfiguration
+    assert_same list_manager.config.class, List::Configuration
+  end
+  
+  def test_current_page_should_return_the_instance_of_ListPage
+    assert_instance_of List::Page, list_manager.current_page
+  end
+  
+  def test_current_page_state_should_return_the_instance_of_ListPageState
+    assert_instance_of List::PageState, list_manager.current_page_state
+  end
+  
+  def test_switch_current_should_replace_own_current_page_property_by_the_given_page
+    report = create_report {|r| r.start_new_page }
+    list   = report.page.list(:list)
+    new_page = List::Page.new(report.page, list.internal.format)
+    
+    list.manager.switch_current!(new_page)
+    
+    assert_same list.manager.current_page, new_page
+  end
+  
+  def test_switch_current_should_replace_own_current_page_state_property_by_internal_property_of_the_given_page
+    report = create_report {|r| r.start_new_page }
+    list   = report.page.list(:list)
+    new_page = List::Page.new(report.page, list.internal.format)
+    
+    list.manager.switch_current!(new_page)
+    
+    assert_same list.manager.current_page_state, new_page.internal
+  end
+  
+  def test_switch_current_should_return_the_self
+    report = create_report {|r| r.start_new_page }
+    list   = report.page.list(:list)
+    new_page = List::Page.new(report.page, list.internal.format)
+    
+    assert_same list.manager.switch_current!(new_page), list.manager
+  end
+  
+  def test_finalize_page_should_dispatch_page_finalize_event
+    flag = false
+    
+    report = create_report do |r|
+      r.layout.config.list(:list) do
+        events.on :page_finalize do |e|
+          flag = true
+        end
+      end
+    end
+    
+    report.start_new_page do |page|
+      page.list(:list).manager.finalize_page
+    end
+    
+    assert flag, 'The :page_finalize event was not dispatched.'
+  end
+  
+  def test_page_property_which_dispatcher_of_finalize_page_event_should_return_the_current_page
+    page_used_in_event = nil
+    
+    report = create_report do |r|
+      r.layout.config.list(:list) do
+        events.on :page_finalize do |e|
+          page_used_in_event = e.page
+        end
+      end
+    end
+    
+    current_page = report.start_new_page
+    current_page.list(:list).manager.finalize_page
+    
+    assert_same page_used_in_event, current_page
+  end
+  
+  def test_list_property_which_dispatcher_of_finalize_event_should_return_the_current_page_of_list
+    list_used_in_event = nil
+    
+    report = create_report do |r|
+      r.layout.config.list(:list) do
+        events.on :page_finalize do |e|
+          list_used_in_event = e.list
+        end
+      end
+    end
+    
+    report.start_new_page
+    current_list = report.page.list(:list)
+    current_list.manager.finalize_page
+    
+    assert_same list_used_in_event, current_list
+  end
+end

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

@@ -7,4 +7,61 @@ class ThinReports::Core::Shape::List::TestPage < MiniTest::Unit::TestCase
   
   # Alias
   List = ThinReports::Core::Shape::List
+  
+  def create_report(&block)
+    create_basic_report('basic_list_layout.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_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
 end

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

@@ -21,7 +21,7 @@ class ThinReports::Core::Shape::List::TestSectionFormat < MiniTest::Unit::TestCa
   def test_build
     shape_format = flexmock(:id => 'mock')
     
-    flexmock(Shape::Tblock::Format).
+    flexmock(Shape::TextBlock::Format).
         should_receive(:build).times(2).and_return(shape_format)
     flexmock(Shape::Basic::Format).
         should_receive(:build).times(1).and_return(shape_format)

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

@@ -8,45 +8,52 @@ class ThinReports::Core::Shape::List::TestSectionInterface < MiniTest::Unit::Tes
   # Alias
   List = ThinReports::Core::Shape::List
   
-  def setup
-    parent = flexmock('parent')
-    format = flexmock('format')
-    
-    @interface = List::SectionInterface.new(parent, format, :section)
+  def create_interface(format_config = {})
+    List::SectionInterface.new(flexmock('parent'),
+                               List::SectionFormat.new(format_config),
+                               :section)
   end
   
-  def test_undef_list_method
-    refute_respond_to @interface, :list
+  def test_internal_should_return_instance_of_SectionInternal
+    assert_instance_of List::SectionInternal, create_interface.internal
   end
   
-  def test_internal
-    assert_instance_of List::SectionInternal, @interface.internal
+  def test_initialize_should_properly_set_the_specified_section_name_to_internal
+    assert_equal create_interface.internal.section_name, :section
   end
   
-  def test_properly_set_init_item_handler
-    shape_format = flexmock('shape_format')
-    
-    flexmock(ThinReports::Core::Shape).
-      should_receive(:Interface).with(@interface, shape_format).once
-      
-    @interface.manager.init_item(shape_format)
+  def test_initialize_should_properly_initialize_manager
+    assert_instance_of ThinReports::Core::Shape::Manager::Internal,
+                       create_interface.manager
   end
   
-  def test_copy
-    original_foo = flexmock('original_foo')
-    copied_foo   = flexmock('copied_foo')
-
-    flexmock(original_foo).
-      should_receive(:copy).and_return(copied_foo).once
-    @interface.manager.shapes[:foo] = original_foo
-    
-    copied_interface = @interface.copy(flexmock('new_parent'))
+  def test_height_should_operate_as_delegator_of_internal
+    list = create_interface('height' => 100)
+    assert_same list.height, list.internal.height
+  end
+  
+  def test_copied_interface_should_succeed_an_section_name_of_original
+    list = create_interface
+    assert_same list.copy(flexmock('new_parent')).internal.section_name,
+                list.internal.section_name
+  end
+  
+  def test_copied_interface_should_have_all_the_copies_of_Shape_which_original_holds
+    list = create_interface
+    copied_list(list) do |new_list|
+      assert_equal new_list.manager.shapes.size, 3
+    end
+  end
+  
+  def copied_list(list, &block)
+    tblock     = ThinReports::Core::Shape::TextBlock
+    new_parent = flexmock('new_parent')
     
-    assert_instance_of List::SectionInterface, copied_interface
-    refute_equal @interface.object_id, copied_interface.object_id
+    %w( foo bar hoge ).each do |id|
+      list.manager.format.shapes[id.to_sym] = tblock::Format.new('type' => 's-tblock', 'id' => id)
+      list.item(id).value(10)
+    end
     
-    assert_equal copied_interface.internal.section_name,
-                 @interface.internal.section_name
-    assert_same copied_interface.manager.shapes[:foo], copied_foo
+    block.call(list.copy(new_parent))
   end
 end