thinreports 0.6.0.pre3

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

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Base::TestInterface < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  class TestInterface < ThinReports::Core::Shape::Base::Interface
+    internal_delegators :m1, :m2
+    
+    # For testing
+    # Instead, #internal method is overwritten by flexmock.
+    def init_internal(parent, format)
+      # Nothing to do
+    end
+  end
+  
+  def setup
+    internal   = flexmock(:m1 => 'm1', :m2 => 'm2')
+    @interface = TestInterface.new(flexmock('parent'), flexmock('format'))
+    
+    flexmock(@interface, :internal => internal)
+  end
+  
+  def test_internal_delegators_macro
+    assert_respond_to @interface, :m1
+    assert_respond_to @interface, :m2
+  end
+  
+  def test_methods_delegated_from_internal
+    assert_same @interface.m1, @interface.internal.m1
+    assert_same @interface.m2, @interface.internal.m2
+  end
+  
+  def test_forced_to_specify_an_internal_argument
+    internal  = flexmock('forced_internal')
+    interface = TestInterface.new(flexmock('parent'), flexmock('format'), 
+                                  internal)
+    
+    assert_same internal, interface.internal
+  end
+  
+  def test_copy
+    flexmock(@interface.internal, :copy   => flexmock('new_internal'),
+                                  :format => flexmock('format'))
+    
+    new_interface = @interface.copy(flexmock('new_parent'))
+    
+    refute_same new_interface, @interface
+    assert_instance_of TestInterface, new_interface
+  end
+end

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

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Base::TestInternal < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  class TestInternal < ThinReports::Core::Shape::Base::Internal
+    format_delegators :m1, :m2
+  end
+  
+  def setup
+    @internal = TestInternal.new(flexmock('parent'),
+                                 flexmock(:m1 => 'm1', :m2 => 'm2'))
+  end
+  
+  def test_format_delegators_macro
+    assert_respond_to @internal, :m1
+    assert_respond_to @internal, :m2
+  end
+  
+  def test_methods_delegated_from_format
+    assert_same @internal.m1, @internal.format.m1
+    assert_same @internal.m2, @internal.format.m2
+  end
+  
+  def test_switch_parent!
+    new_parent = flexmock('new_parent')
+    res = @internal.switch_parent!(new_parent)
+    
+    assert_same @internal, res
+    assert_same @internal.parent, new_parent
+  end
+  
+  def test_available_style?
+    assert_operator @internal, :available_style?, :fill
+    assert_operator @internal, :available_style?, :stroke
+    
+    refute_operator @internal, :available_style?, 'font-family'
+    refute_operator @internal, :available_style?, :x
+  end
+  
+  def test_attributes
+    format = flexmock('format')
+    format.should_receive(:svg_attrs).
+      and_return('fill' => 'red',
+                 'stroke' => 'black',
+                 'x' => 100,
+                 'y' => 100,
+                 'width' => 200)
+    internal = TestInternal.new(flexmock('parent'), format)
+    internal.attrs['fill'] = '#ff0000'
+    internal.attrs['stroke'] = '#000000'
+    
+    assert_equal internal.attributes, {'fill' => '#ff0000',
+                                       'stroke' => '#000000',
+                                       'x' => 100,
+                                       'y' => 100,
+                                       'width' => 200}
+  end
+  
+  def test_copy
+    @internal.attrs.update('stroke' => 'red')
+    @internal.states.update(:value => '123')
+    
+    new_internal = @internal.copy(flexmock('new_parent'))
+    
+    refute_same @internal, new_internal
+    assert_instance_of TestInternal, new_internal
+    
+    # Test for parent property
+    refute_same @internal.parent, new_internal.parent
+    
+    # Test for format property
+    assert_same @internal.format, new_internal.format
+    
+    # Test for attrs
+    args_attrs_test = [@internal.attrs, new_internal.attrs]
+    
+    assert_equal(*args_attrs_test)
+    refute_same(*args_attrs_test)
+    
+    # Test for value of attrs
+    args_attr_values_test = [@internal.attrs['stroke'],
+                            new_internal.attrs['stroke']]
+    
+    assert_equal(*args_attr_values_test)
+    refute_same(*args_attr_values_test)
+    
+    @internal.attrs['fill'] = 'black'
+    assert_nil new_internal.attrs['fill']
+    
+    # Test for states
+    args_states_test = [@internal.states, new_internal.states]
+    
+    assert_equal(*args_states_test)
+    refute_same(*args_states_test)
+    
+    # Test for value of states
+    args_state_values_test = [@internal.states[:value],
+                              new_internal.states[:value]]
+    
+    assert_equal(*args_state_values_test)
+    refute_same(*args_state_values_test)
+
+    @internal.states[:value].reverse!
+    refute_equal(*args_state_values_test)
+  end
+end

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

@@ -0,0 +1,59 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Basic::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  TEST_BASIC_FORMAT = {
+    "type" => "s-rect",
+    "id" => "rect_1",
+    "display" => "true",
+    "svg" => {
+      "tag" => "rect",
+      "attrs" => {
+        "stroke" => "#000000",
+        "stroke-width" => "1",
+        "fill" => "#ff0000",
+        "fill-opacity" => "1",
+        "stroke-dasharray" => "none",
+        "rx" => "0",
+        "ry" => "0",
+        "width" => "196.1",
+        "height" => "135.1",
+        "x" => "85",
+        "y" => "82"
+      }
+    }
+  }
+
+  # Alias
+  Format = ThinReports::Core::Shape::Basic::Format
+
+  def test_build_basic_format
+    build_basic_format
+  rescue => e
+    flunk exception_details(e, 'Building failed.')
+  end
+  
+  def test_basic_config_readers
+    format = Format.new(TEST_BASIC_FORMAT)
+    
+    assert_equal format.id, 'rect_1'
+    assert_equal format.type, 's-rect'
+    assert_equal format.svg_tag, 'rect'
+    assert_equal format.display?, true
+    assert_equal format.svg_attrs['stroke'], '#000000'
+    assert_equal format.svg_attrs['stroke-dasharray'], 'none'
+  end
+  
+  def test_display?
+    format = Format.new('display' => 'false')
+    
+    assert_equal format.display?, false
+  end
+  
+  def build_basic_format
+    Format.build(TEST_BASIC_FORMAT)
+  end
+end

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

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Basic::TestInterface < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  # Alias
+  Basic = ThinReports::Core::Shape::Basic
+  
+  def setup
+    format = flexmock('format')
+    format.should_receive(:display? => true)
+    
+    @basic = Basic::Interface.new(flexmock('parent'), format)
+  end
+  
+  def test_visible
+    assert_equal @basic.visible?, true
+    @basic.visible(false)
+    assert_equal @basic.visible?, false
+  end
+  
+  def test_style
+    @basic.style(:fill, '#ff0000')
+    @basic.style(:stroke, '#0000ff')
+    
+    assert_equal @basic.internal.attrs, {'fill' => '#ff0000',
+                                         'stroke' => '#0000ff'}
+    assert_raises ThinReports::Errors::UnknownShapeStyleName do
+      @basic.style(:unknown, 'unknown value')
+    end
+  end
+  
+  def test_styles
+    @basic.styles(:fill => 'red', :stroke => 'blue')
+    
+    assert_equal @basic.internal.attrs, {'fill' => 'red',
+                                         'stroke' => 'blue'}
+    assert_raises ThinReports::Errors::UnknownShapeStyleName do
+      @basic.styles(:fill => 'blue', :unknown => 'black')
+    end
+  end
+  
+  def test_hide
+    @basic.hide
+    assert_equal @basic.visible?, false
+  end
+  
+  def test_show
+    @basic.visible(false)
+    @basic.show
+    assert_equal @basic.visible?, true
+  end
+  
+  def test_method_chain
+    @basic.hide.show
+    assert_equal @basic.visible?, true
+    
+    @basic.style(:fill, 'red').hide
+    assert_equal @basic.internal.attrs['fill'], 'red'
+    assert_equal @basic.visible?, false
+    
+    @basic.styles(:fill => 'red', :stroke => 'blue').style(:fill, 'black')
+    assert_equal @basic.internal.attrs['fill'], 'black'
+    
+    @basic.visible(true).visible(false)
+    assert_equal @basic.visible?, false
+  end
+end

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

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Basic::TestInternal < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  Basic = ThinReports::Core::Shape::Basic
+  
+  def setup
+    format = flexmock('format')
+    format.should_receive(:display? => true)
+    
+    @internal = Basic::Internal.new(flexmock('parent'), format)
+  end
+  
+  def test_visible
+    assert_equal @internal.visible?, true
+    
+    @internal.visible(false)
+    
+    assert_equal @internal.visible?, false
+    assert_equal @internal.format.display?, true
+  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'}
+  end
+  
+  def test_type_of?
+    flexmock(@internal.format).should_receive(:type => 's-rect')
+    
+    assert_equal @internal.type_of?(:basic), true
+    assert_equal @internal.type_of?(:rect), true
+    assert_equal @internal.type_of?(:tblock), false
+  end
+end

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

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+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')
+    @config = List::Configuration.new
+  end  
+  
+  def test_use_stores
+    flexmock(List::Store).should_receive(:init).with(::Hash).once
+    
+    @config.use_stores(:a => 0, :b => 0)
+  end
+  
+  def test_store
+    flexmock(List::Store).should_receive(:init => @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_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)
+    
+    @config = List::Configuration.new
+    @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

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestEvents < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  List = ThinReports::Core::Shape::List
+  
+  def setup
+    @events = List::Events.new
+  end
+  
+  def test_allowed_event_types
+    assert_equal @events.instance_variable_get(:@types),
+                 [:page_footer_insert, :footer_insert]
+  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
+  end
+end

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

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::List::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  TEST_LIST_FORMAT = {
+    "type" => "s-list",
+    "id" => "List",
+    "display" => "true",
+    "page-footer-enabled" => "true",
+    "footer-enabled" => "true",
+    "header-enabled" => "true",
+    "page-break" => "true",
+    "content-height" => 255,
+    "detail" => {},
+    "footer" => {},
+    "page-footer" => {},
+    "header" => {},
+    "svg" => {
+      "tag" => "g",
+      "attrs" => {}
+    }
+  }
+  
+  List = ThinReports::Core::Shape::List
+  
+  def test_build_when_all_sections_enabled
+    flexmock(List::SectionFormat).
+        should_receive(:build).times(4).and_return({})
+    
+    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({})
+    
+    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
+    end
+  end
+
+  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
+end