thinreports 0.6.0.pre3 → 0.7.0

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

@@ -8,23 +8,48 @@ class ThinReports::Core::Shape::List::TestSectionInternal < MiniTest::Unit::Test
   # Alias
   List = ThinReports::Core::Shape::List
   
-  def setup
-    parent = flexmock('parent')
-    format = flexmock(:height        => 100,
-                      :relative_left => 100,
-                      :relative_top  => 200,
-                      :svg_tag       => 'g')
-    @internal = List::SectionInternal.new(parent, format)
+  def create_internal(format_config = {})
+    List::SectionInternal.new(flexmock('parent'),
+                              List::SectionFormat.new(format_config))
   end
   
-  def test_move_top_to
-    @internal.move_top_to(100)
-    assert_equal @internal.states[:relative_top], 100
+  def test_height_should_operate_as_delegator_of_format
+    list = create_internal('height' => 100)
+    assert_same list.height, list.format.height
   end
   
-  def test_relative_position
-    assert_equal @internal.relative_position, [100, 200]
-    @internal.move_top_to(50)
-    assert_equal @internal.relative_position, [100, 250]
+  def test_relative_left_should_operate_as_delegator_of_format
+    list = create_internal('translate' => {'x' => 10})
+    assert_same list.relative_left, list.format.relative_left
+  end
+  
+  def test_relative_top_should_operate_as_delegator_of_format
+    list = create_internal('translate' => {'y' => 10})
+    assert_same list.relative_top, list.format.relative_top
+  end
+  
+  def test_svg_tag_should_operate_as_delegator_of_format
+    list = create_internal('svg' => {'tag' => 'g'})
+    assert_same list.svg_tag, list.format.svg_tag
+  end
+    
+  def test_move_top_to_should_properly_set_value_to_states_as_relative_top
+    list = create_internal
+    list.move_top_to(200)
+    
+    assert_equal list.states[:relative_top], 200
+  end
+  
+  def test_relative_position_should_return_Array_included_coordinates
+    list = create_internal('translate' => {'x' => 100, 'y' => 200})
+    
+    assert_equal list.relative_position, [100, 200]
+  end
+  
+  def test_Y_coordinate_which_relative_position_returns_should_be_calculated_position_with_relative_top_of_states
+    list = create_internal('translate' => {'x' => 100, 'y' => 100})
+    list.move_top_to(50)
+    
+    assert_equal list.relative_position.last, 150
   end
 end

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

@@ -5,36 +5,30 @@ require 'test/unit/helper'
 class ThinReports::Core::Shape::Manager::TestFormat < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
-  class TestFormat < ThinReports::Core::Shape::Manager::Format
-  end
+  class TestFormat < ThinReports::Core::Shape::Manager::Format; end
   
-  def test_identifier_equal_the_object_id
+  def test_identifier_should_return_the_same_as_object_id_when_id_is_not_given
     format = TestFormat.new({})
     assert_equal format.identifier, format.object_id
   end
   
-  def test_identifier_equal_the_given_id
-    format = TestFormat.new({}, :any_id)
-    assert_equal format.identifier, :any_id
+  def test_identifier_should_return_the_specified_id_when_id_is_given
+    assert_equal TestFormat.new({}, :any_id).identifier, :any_id
   end
   
-  def test_shapes
-    format = TestFormat.new({})
-    assert_instance_of ThinReports::Core::OrderedHash, format.shapes
+  def test_shapes_should_return_instance_of_OrderedHash
+    assert_instance_of ThinReports::Core::OrderedHash, TestFormat.new({}).shapes
   end
   
-  def test_find_shape
+  def test_find_shape_should_return_format_of_shape_when_shape_is_found
     format = TestFormat.new({}) do |f|
-      f.shapes[:foo] = 'foo'
-      f.shapes[:boo] = 'boo'
+      f.shapes[:foo] = ThinReports::Core::Shape::TextBlock::Format.new('id'   => 'foo',
+                                                                       'type' => 's-tblock')
     end
-    
-    assert_equal format.find_shape(:foo), 'foo'
-    assert_equal format.find_shape(:boo), 'boo'
+    assert_equal format.find_shape(:foo).id, 'foo'
   end
   
-  def test_find_shape_return_nil_when_id_is_not_found
-    format = TestFormat.new({})
-    assert_nil format.find_shape(:unknown)
+  def test_find_shape_should_return_nil_when_shape_is_not_found
+    assert_nil TestFormat.new({}).find_shape(:unknown)
   end
 end

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

@@ -5,133 +5,167 @@ require 'test/unit/helper'
 class ThinReports::Core::Shape::Manager::TestInternal < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
-  def setup
-    @init_item_handler = flexmock('init_item_handler')
-    
-    @format_tblock = flexmock(:type => 's-tblock')
-    @format_list   = flexmock(:type => 's-list')
-    @format_rect   = flexmock(:type => 's-rect')
-    
-    @item_tblock   = flexmock(:type => 's-tblock')
-    @item_list     = flexmock(:type => 's-list')
-    @item_rect     = flexmock(:type => 's-rect')
+  # Alias
+  Shape = ThinReports::Core::Shape
+  
+  def create_shape_format(type, id, other_config = {})
+    Shape::Format(type).new({'id'      => id,
+                             'type'    => type,
+                             'display' => 'true'}.merge(other_config))
+  end
+  
+  def create_internal(&block)
+    report = create_basic_report('basic_layout1.tlf')
+    format = report.layout.format
     
-    layout_format = flexmock('layout_format')
+    # Add to default dummy shapes.
+    format.shapes[:t1] = create_shape_format('s-tblock', 't1', 'value' => '')
+    format.shapes[:t2] = create_shape_format('s-tblock', 't2', 'value' => '')
+    format.shapes[:ls] = create_shape_format('s-list', 'ls')
     
-    layout_format.should_receive(:find_shape).
-      with(:tblock).and_return(@format_tblock)
-    layout_format.should_receive(:find_shape).
-      with(:list).and_return(@format_list)
-    layout_format.should_receive(:find_shape).
-      with(:rect).and_return(@format_rect)
-    layout_format.should_receive(:find_shape).
-      with(:unknown).and_return(nil)
+    block.call(format) if block_given?
     
-    @manager = ThinReports::Core::Shape::Manager::Internal.new(layout_format,
-                                                               @init_item_handler)
+    report.start_new_page.manager
   end
   
-  def test_find_format
-    assert_same @manager.find_format(:tblock), @format_tblock
-    assert_same @manager.find_format('list'), @format_list
-    assert_nil  @manager.find_format(:unknown)
+  def test_find_format_should_return_format_with_the_specified_Symbol_id
+    assert_equal create_internal.find_format(:t1).id, 't1'
   end
   
-  def test_valid_type?
-    # Without limit options.
-    assert_equal @manager.valid_type?('s-list'), true
-    # With only limitation.
-    assert_equal @manager.valid_type?('s-list', :only => 's-list'), true
-    assert_equal @manager.valid_type?('s-list', :only => 'other'), false
-    # With except limitation.
-    assert_equal @manager.valid_type?('s-list', :except => 'other'), true
-    assert_equal @manager.valid_type?('s-list', :except => 's-list'), false
+  def test_find_format_should_return_format_with_the_specified_String_id
+    assert_equal create_internal.find_format('t2').id, 't2'
   end
   
-  def test_find_item
-    flexmock(@init_item_handler).
-      should_receive(:call).once.and_return(@item_tblock)
-    
-    # Should initialize item.
-    @manager.find_item(:tblock)
-    # Should be stored a one initialized item.
-    assert_equal @manager.shapes.size, 1
-    assert_same @manager.shapes[:tblock], @item_tblock
-    
-    flexmock(@init_item_handler).
-      should_receive(:call).times(0)
-    
-    # Should must not be initialized when given a initialized item.
-    assert_same @manager.find_item(:tblock), @item_tblock
+  def test_find_format_should_return_nil_when_format_with_specified_id_is_not_found
+    assert_nil create_internal.find_format(:unknown)
+  end
+  
+  def test_find_item_should_return_shape_with_the_specified_id
+    assert_instance_of Shape::TextBlock::Interface, create_internal.find_item(:t1)
+  end
+  
+  def test_find_item_should_return_shape_in_shapes_registry_when_the_specified_shape_exists_in_registry
+    internal = create_internal
+    internal.find_item(:t1)
     
-    # Should returnes the nil value when given unknown item.
-    assert_nil @manager.find_item(:unknown)
+    assert_same internal.find_item(:t1), internal.shapes[:t1]
+  end
+  
+  def test_find_item_should_return_shape_when_passing_in_the_specified_only_filter
+    internal = create_internal
+    assert_equal internal.find_item(:t1, :only => 's-tblock').id, 't1'
+  end
+  
+  def test_find_item_should_return_nil_when_not_passing_in_the_specified_only_filter
+    internal = create_internal
+    assert_nil internal.find_item(:t1, :only => 's-list')
   end
   
-  def test_find_item_with_limitation
-    # Should returns the nil value when outside limitation.
-    assert_nil @manager.find_item(:tblock, :only => 's-list')
-    assert_nil @manager.find_item(:list, :except => 's-list')
+  def test_find_item_should_return_shape_when_passing_in_the_specified_except_filter
+    internal = create_internal
+    assert_equal internal.find_item(:ls, :except => 's-tblock').id, 'ls'
+  end
+  
+  def test_find_item_should_return_shape_when_not_passing_in_the_specified_except_filter
+    internal = create_internal
+    assert_nil internal.find_item(:ls, :except => 's-list')
+  end
+  
+  def test_final_shape_should_return_nil_when_shape_is_not_found
+    internal = create_internal
+    assert_nil internal.final_shape(:unknown)
+  end
+  
+  def test_final_shape_should_return_nil_when_shape_is_stored_in_shapes_and_hidden
+    internal = create_internal
+    internal.find_item(:t1).hide
     
-    flexmock(@init_item_handler).
-      should_receive(:call).and_return(@item_tblock)
+    assert_nil internal.final_shape(:t1)
+  end
+  
+  def test_final_shape_should_return_shape_when_shape_is_stored_in_shapes_and_not_Block
+    internal = create_internal do |f|
+      f.shapes[:rect] = create_shape_format('s-rect', 'rect')
+    end
+    internal.find_item(:rect)
     
-    # Should initialize and store item.
-    @manager.find_item(:tblock, :except => 's-list')
-    assert_equal @manager.shapes[:tblock], @item_tblock
+    assert_equal internal.final_shape(:rect).id, 'rect'
+  end
+  
+  def test_final_shape_should_return_shape_when_shape_is_stored_in_shapes_and_TextBlock_with_value
+    internal = create_internal
+    internal.find_item(:t1).value('value')
     
-    # Should returns the nil value.
-    assert_nil @manager.find_item(:tblock, :only => 's-list')
+    assert_equal internal.final_shape(:t1).id, 't1'
   end
   
-  def test_final_shape_when_give_the_initialized_item_that_visibility_is_enabled
-    @manager.shapes[:tblock] = flexmock(:visible? => true)
+  def test_final_shape_should_return_nil_when_shape_is_stored_in_shapes_and_TextBlock_with_no_value
+    internal = create_internal
+    internal.find_item(:t2)
     
-    assert_same @manager.final_shape(:tblock), @manager.shapes[:tblock]
+    assert_nil internal.final_shape(:t2)
   end
   
-  def test_final_shape_when_give_the_initialized_item_that_visibility_is_disabled
-    @manager.shapes[:tblock] = flexmock(:visible? => false)
+  def test_final_shape_should_return_shape_when_shape_is_stored_in_shapes_and_ImageBlock_with_src
+    internal = create_internal do |f|
+      f.shapes[:iblock] = create_shape_format('s-iblock', 'iblock')
+    end
+    internal.find_item(:iblock).src('/path/to/image.png')
     
-    assert_nil @manager.final_shape(:tblock)
+    assert_equal internal.final_shape(:iblock).id, 'iblock'
   end
   
-  def test_final_shape_when_give_the_uninitialized_basic_item
-    flexmock(@format_rect, :display? => true)
+  def test_final_shape_should_return_nil_when_shape_is_stored_in_shapes_and_ImageBlock_with_no_src
+    internal = create_internal do |f|
+      f.shapes[:iblock] = create_shape_format('s-iblock', 'iblock')
+    end
     
-    flexmock(@init_item_handler).
-      should_receive(:call).once.and_return(@item_rect)
+    assert_nil internal.final_shape(:iblock)
+  end
+  
+  def test_final_shape_should_return_nil_when_shape_isnot_stored_in_shapes_and_hidden
+    internal = create_internal do |f|
+      f.shapes[:t3] = create_shape_format('s-tblock', 't3', 'display' => 'false')
+    end
     
-    # Should initialize item.
-    assert_same @manager.final_shape(:rect), @item_rect
+    assert_nil internal.final_shape(:t3)
   end
   
-  def test_final_shape_return_nil_when_give_the_tblock_item_that_has_no_value
-    flexmock(@format_tblock, :display? => true,
-                             :has_reference? => false,
-                             :value => '')
-    assert_nil @manager.final_shape(:tblock)
+  def test_final_shape_should_return_shape_when_shape_isnot_stored_in_shapes_and_not_Block
+    internal = create_internal do |f|
+      f.shapes[:rect] = create_shape_format('s-rect', 'rect')
+    end
+    
+    assert_equal internal.final_shape(:rect).id, 'rect'
   end
   
-  def test_final_shape_initialize_item_when_give_the_tblock_item_that_has_an_reference
-    flexmock(@format_tblock, :display? => true,
-                             :has_reference? => true,
-                             :value => '')
+  def test_final_shape_should_return_nil_when_shape_isnot_stored_in_shapes_and_ImageBlock
+    internal = create_internal do |f|
+      f.shapes[:iblock] = create_shape_format('s-iblock', 'iblock')
+    end
     
-    flexmock(@init_item_handler).
-      should_receive(:call).once.and_return(@item_tblock)
+    assert_nil internal.final_shape(:iblock)
+  end
+  
+  def test_final_shape_should_return_shape_when_shape_isnot_stored_in_shapes_and_TextBlock_with_value
+    internal = create_internal do |f|
+      f.shapes[:t3] = create_shape_format('s-tblock', 't3', 'value' => 'default value')
+    end
     
-    assert_same @manager.final_shape(:tblock), @item_tblock
+    assert_equal internal.final_shape(:t3).id, 't3'
   end
   
-  def test_final_shape_initialize_item_when_give_the_tblock_item_that_has_a_value
-    flexmock(@format_tblock, :display? => true,
-                             :has_reference? => false,
-                             :value => 'value')
+  def test_final_shape_should_return_shape_when_shape_isnot_stored_in_shapes_and_TextBlock_with_reference
+    internal = create_internal do |f|
+      f.shapes[:t3] = create_shape_format('s-tblock', 't3', 'ref-id' => 't1')
+    end
     
-    flexmock(@init_item_handler).
-      should_receive(:call).once.and_return(@item_tblock)
+    assert_equal internal.final_shape(:t3).id, 't3'
+  end
+  
+  def test_final_shape_should_return_nil_when_shape_isnot_stored_in_shapes_and_TextBlock_with_no_value_no_reference
+    internal = create_internal
     
-    assert_same @manager.final_shape(:tblock), @item_tblock    
+    assert_nil internal.final_shape(:t1)
   end
 end

data/test/unit/core/shape/manager/test_target.rb

@@ -8,102 +8,109 @@ class ThinReports::Core::Shape::Manager::TestTarget < MiniTest::Unit::TestCase
   # Alias
   Shape = ThinReports::Core::Shape
   
-  class TestFormat < Shape::Manager::Format; end
-  
   class TestManager
     include Shape::Manager::Target
     
-    def initialize(format)
-      initialize_manager(format) do |f|
+    attr_reader :layout, :report
+    
+    def initialize(report, layout)
+      @report = report
+      @layout = layout
+      
+      initialize_manager(layout.format) do |f|
         Shape::Interface(self, f)
       end
     end
   end
   
-  def setup
-    tblock1_format = Shape::Tblock::Format.new('id'   => 'tblock1',
-                                               'type' => 's-tblock')
-    tblock2_format = Shape::Tblock::Format.new('id'   => 'tblock2',
-                                               'type' => 's-tblock')
-    list_format    = Shape::List::Format.new('id' => 'list',
-                                             'type' => 's-list')
+  def create_shape_format(type, id)
+    Shape::Format(type).new('id' => id, 'type' => type)
+  end
+  
+  def create_manager
+    report = create_basic_report('basic_layout1.tlf')
+    layout = report.layout
     
-    @format = TestFormat.new({}) do |f|
-      f.shapes[:tblock1] = tblock1_format
-      f.shapes[:tblock2] = tblock2_format
-      f.shapes[:list]    = list_format
-    end
-    @manager = TestManager.new(@format)
+    # Add to dummy shapes.
+    layout.format.shapes[:t1] = create_shape_format('s-tblock', 't1')
+    layout.format.shapes[:t2] = create_shape_format('s-tblock', 't2')
+    layout.format.shapes[:ls] = create_shape_format('s-list', 'ls')
+    
+    TestManager.new(report, layout)
+  end
+  
+  def test_manager_should_return_instance_of_ManagerInternal
+    assert_instance_of Shape::Manager::Internal, create_manager.manager
   end
   
-  def test_item_with_Symbol_id
-    assert_instance_of Shape::Tblock::Interface, @manager.item(:tblock1)
+  def test_item_should_properly_return_shape_with_the_specified_Symbol_id
+    assert_equal create_manager.item(:t1).id, 't1'
   end
   
-  def test_item_with_String_id
-    assert_instance_of Shape::Tblock::Interface, @manager.item('tblock1')
+  def test_item_should_properly_return_shape_with_the_specified_String_id
+    assert_equal create_manager.item('t2').id, 't2'
   end
   
-  def test_item_raise_error_when_given_the_id_of_list
+  def test_item_should_raise_when_the_shape_with_the_specified_id_is_not_found
     assert_raises ThinReports::Errors::UnknownItemId do
-      @manager.item(:list)
+      create_manager.item(:unknown)
     end
   end
   
-  def test_item_raise_error_when_given_the_unknown_id
+  def test_item_should_set_an_shape_as_argument_when_a_block_is_given
+    id = nil
+    create_manager.item(:t1) {|s| id = s.id }
+    assert_equal id, 't1'
+  end
+  
+  def test_item_should_raise_when_type_of_shape_with_the_specified_id_is_list
     assert_raises ThinReports::Errors::UnknownItemId do
-      @manager.item(:unknown)
+      create_manager.item(:ls)
     end
   end
   
-  def test_item_with_block_that_has_no_arguments
-    @manager.item(:tblock1) do
-      value(1000)
-    end
-    assert_equal @manager.item(:tblock1).value, 1000
+  def test_list_should_properly_return_list_with_the_specified_Symbol_id
+    assert_equal create_manager.list(:ls).id, 'ls'
   end
   
-  def test_item_with_block_that_has_an_argument
-    @manager.item(:tblock2) do |t|
-      t.value(1000)
-    end
-    assert_equal @manager.item(:tblock2).value, 1000
+  def test_list_should_properly_return_list_with_the_specified_String_id
+    assert_equal create_manager.list('ls').id, 'ls'
   end
   
-  def test_list_raise_error_when_given_id_of_non_list
+  def test_list_should_raise_when_type_of_shape_with_the_specified_id_is_not_list
     assert_raises ThinReports::Errors::UnknownItemId do
-      @manager.list(:tblock1)
+      create_manager.list(:t1)
     end
   end
   
-  def test_list_should_be_stored_in_the_special_store
-    flexmock(@manager).
-      should_receive(:find_item).and_return(flexmock('item_list'))
+  def test_values_should_properly_set_values_to_shapes_with_specified_id
+    manager = create_manager
+    manager.values(:t1 => 1000, 't2' => 'value')
     
-    @manager.list(:list)
-    assert_includes @manager.manager.lists, :list
+    assert_equal [manager.item(:t1).value, manager.item(:t2).value], [1000, 'value']
   end
   
-  def test_items_should_be_warned_as_deprecated
+  def test_items_should_show_deprecation_warning
     out, err = capture_io do
-      @manager.items :tblock1 => 1000
+      create_manager.items(:t1 => 1000)
     end
     assert_match %r!DEPRECATION!, err
   end
   
-  def test_values
-    @manager.values :tblock1 => 1000,
-                    :tblock2 => 2000
-    
-    assert_equal @manager.item(:tblock1).value, 1000
-    assert_equal @manager.item(:tblock2).value, 2000
+  def test_item_exists_asker_should_return_true_when_shape_with_specified_Symbol_id_is_found
+    assert_equal create_manager.item_exists?(:t1), true
+  end
+  
+  def test_item_exists_asker_should_return_true_when_shape_with_specified_String_id_is_found
+    assert_equal create_manager.item_exists?('t2'), true
+  end
+  
+  def test_item_exists_asker_should_return_false_when_shape_with_specified_id_not_found
+    assert_equal create_manager.item_exists?('unknown'), false
   end
   
-  def test_item_exists?
-    assert_equal @manager.item_exists?(:tblock1), true
-    assert_equal @manager.item_exists?('list'), true
-    assert_equal @manager.item_exists?(:unknown), false
-    # Alias method
-    assert_equal @manager.exists?(:tblock1), true
+  def test_exists_asker_should_operate_like_as_item_exists_asker
+    manager = create_manager
+    assert_equal manager.exists?(:unknown), manager.item_exists?(:unknown)
   end
 end