thinreports 0.6.0.pre3

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

@@ -0,0 +1,10 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestPage < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  List = ThinReports::Core::Shape::List
+end

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

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestPageState < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  List = ThinReports::Core::Shape::List
+  
+  def setup
+    parent = flexmock('parent')
+    format = flexmock('format')
+    
+    @state = List::PageState.new(parent, format)
+  end
+  
+  def test_alias_class
+    assert_same List::PageState, List::Internal
+  end
+  
+  def test_type_of?
+    assert_equal @state.type_of?(:list), true
+  end
+  
+  def test_finalized!
+    assert_equal @state.finalized?, false
+    @state.finalized!
+    assert_equal @state.finalized?, true
+  end
+end

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

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestSectionFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  TEST_LIST_SECTION_FORMAT = {
+    "height" => 47.7,
+    "translate" => {"x" => 0, "y" => -64.2},
+    "svg" => {
+      "tag" => "g",
+      "content" => "<!---SHAPE{\"type\":\"s-tblock\",\"id\":\"t1\"}SHAPE--->" +
+                   "<!---SHAPE{\"type\":\"s-rect\",\"id\":\"r1\"}SHAPE--->" +
+                   "<!---SHAPE{\"type\":\"s-tblock\",\"id\":\"t2\"}SHAPE--->"
+    }
+  }
+  
+  Shape = ThinReports::Core::Shape
+  
+  def test_build
+    shape_format = flexmock(:id => 'mock')
+    
+    flexmock(Shape::Tblock::Format).
+        should_receive(:build).times(2).and_return(shape_format)
+    flexmock(Shape::Basic::Format).
+        should_receive(:build).times(1).and_return(shape_format)
+    begin
+      build_format
+    rescue => e
+      flunk exception_details(e, 'Building failed.')
+    end
+  end
+  
+  def test_config_readers
+    format = Shape::List::SectionFormat.new(TEST_LIST_SECTION_FORMAT)
+    
+    assert_equal format.height, 47.7
+    assert_equal format.relative_left, 0
+    assert_equal format.relative_top, -64.2
+  end
+  
+  def build_format
+    Shape::List::SectionFormat.build(TEST_LIST_SECTION_FORMAT.dup)
+  end
+end

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

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestSectionInterface < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  List = ThinReports::Core::Shape::List
+  
+  def setup
+    parent = flexmock('parent')
+    format = flexmock('format')
+    
+    @interface = List::SectionInterface.new(parent, format, :section)
+  end
+  
+  def test_undef_list_method
+    refute_respond_to @interface, :list
+  end
+  
+  def test_internal
+    assert_instance_of List::SectionInternal, @interface.internal
+  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)
+  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'))
+    
+    assert_instance_of List::SectionInterface, copied_interface
+    refute_equal @interface.object_id, copied_interface.object_id
+    
+    assert_equal copied_interface.internal.section_name,
+                 @interface.internal.section_name
+    assert_same copied_interface.manager.shapes[:foo], copied_foo
+  end
+end

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

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestSectionInternal < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # 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)
+  end
+  
+  def test_move_top_to
+    @internal.move_top_to(100)
+    assert_equal @internal.states[:relative_top], 100
+  end
+  
+  def test_relative_position
+    assert_equal @internal.relative_position, [100, 200]
+    @internal.move_top_to(50)
+    assert_equal @internal.relative_position, [100, 250]
+  end
+end

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

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestStore < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  List = ThinReports::Core::Shape::List
+  
+  def test_new
+    klass = List::Store.new(:foo => 'foo', :hoge => 0)
+    
+    assert_instance_of ::Class, klass
+    
+    st1 = klass.new
+    st2 = klass.new
+    
+    refute_same st1.foo, st2.foo
+    # Fixnum is immutable
+    assert_same st1.hoge, st2.hoge
+  end
+  
+  def test_init
+    store = List::Store.init(:foo => 0, :hoge => 'hoge')
+    
+    assert_respond_to store, :foo
+    assert_respond_to store, :hoge
+    
+    assert_equal store.foo, 0
+    assert_equal store.hoge, 'hoge'
+  end
+  
+  def test_copy
+    store = List::Store.init(:foo => Time.now)
+    
+    copied = store.copy
+    
+    assert_equal store.foo, copied.foo
+    refute_same store.foo, copied.foo
+  end
+end

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

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Manager::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  class TestFormat < ThinReports::Core::Shape::Manager::Format
+  end
+  
+  def test_identifier_equal_the_object_id
+    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
+  end
+  
+  def test_shapes
+    format = TestFormat.new({})
+    assert_instance_of ThinReports::Core::OrderedHash, format.shapes
+  end
+  
+  def test_find_shape
+    format = TestFormat.new({}) do |f|
+      f.shapes[:foo] = 'foo'
+      f.shapes[:boo] = 'boo'
+    end
+    
+    assert_equal format.find_shape(:foo), 'foo'
+    assert_equal format.find_shape(:boo), 'boo'
+  end
+  
+  def test_find_shape_return_nil_when_id_is_not_found
+    format = TestFormat.new({})
+    assert_nil format.find_shape(:unknown)
+  end
+end

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

@@ -0,0 +1,137 @@
+# coding: utf-8
+
+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')
+    
+    layout_format = flexmock('layout_format')
+    
+    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)
+    
+    @manager = ThinReports::Core::Shape::Manager::Internal.new(layout_format,
+                                                               @init_item_handler)
+  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)
+  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
+  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
+    
+    # Should returnes the nil value when given unknown item.
+    assert_nil @manager.find_item(:unknown)
+  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')
+    
+    flexmock(@init_item_handler).
+      should_receive(:call).and_return(@item_tblock)
+    
+    # Should initialize and store item.
+    @manager.find_item(:tblock, :except => 's-list')
+    assert_equal @manager.shapes[:tblock], @item_tblock
+    
+    # Should returns the nil value.
+    assert_nil @manager.find_item(:tblock, :only => 's-list')
+  end
+  
+  def test_final_shape_when_give_the_initialized_item_that_visibility_is_enabled
+    @manager.shapes[:tblock] = flexmock(:visible? => true)
+    
+    assert_same @manager.final_shape(:tblock), @manager.shapes[:tblock]
+  end
+  
+  def test_final_shape_when_give_the_initialized_item_that_visibility_is_disabled
+    @manager.shapes[:tblock] = flexmock(:visible? => false)
+    
+    assert_nil @manager.final_shape(:tblock)
+  end
+  
+  def test_final_shape_when_give_the_uninitialized_basic_item
+    flexmock(@format_rect, :display? => true)
+    
+    flexmock(@init_item_handler).
+      should_receive(:call).once.and_return(@item_rect)
+    
+    # Should initialize item.
+    assert_same @manager.final_shape(:rect), @item_rect
+  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)
+  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 => '')
+    
+    flexmock(@init_item_handler).
+      should_receive(:call).once.and_return(@item_tblock)
+    
+    assert_same @manager.final_shape(:tblock), @item_tblock
+  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')
+    
+    flexmock(@init_item_handler).
+      should_receive(:call).once.and_return(@item_tblock)
+    
+    assert_same @manager.final_shape(:tblock), @item_tblock    
+  end
+end

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

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Manager::TestTarget < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # 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|
+        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')
+    
+    @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)
+  end
+  
+  def test_item_with_Symbol_id
+    assert_instance_of Shape::Tblock::Interface, @manager.item(:tblock1)
+  end
+  
+  def test_item_with_String_id
+    assert_instance_of Shape::Tblock::Interface, @manager.item('tblock1')
+  end
+  
+  def test_item_raise_error_when_given_the_id_of_list
+    assert_raises ThinReports::Errors::UnknownItemId do
+      @manager.item(:list)
+    end
+  end
+  
+  def test_item_raise_error_when_given_the_unknown_id
+    assert_raises ThinReports::Errors::UnknownItemId do
+      @manager.item(:unknown)
+    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
+  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
+  end
+  
+  def test_list_raise_error_when_given_id_of_non_list
+    assert_raises ThinReports::Errors::UnknownItemId do
+      @manager.list(:tblock1)
+    end
+  end
+  
+  def test_list_should_be_stored_in_the_special_store
+    flexmock(@manager).
+      should_receive(:find_item).and_return(flexmock('item_list'))
+    
+    @manager.list(:list)
+    assert_includes @manager.manager.lists, :list
+  end
+  
+  def test_items_should_be_warned_as_deprecated
+    out, err = capture_io do
+      @manager.items :tblock1 => 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
+  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
+  end
+end