thinreports 0.6.0.pre3 → 0.7.0

data/test/unit/core/shape/styles/test_base.rb

@@ -0,0 +1,219 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Style::TestBase < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Style = ThinReports::Core::Shape::Style::Base
+  
+  def create_basic_format(attrs = {})
+    ThinReports::Core::Shape::Basic::Format.new('svg' => {'attrs' => attrs})
+  end
+  
+  def create_style(base = {})
+    Style.new(create_basic_format(base))
+  end
+  
+  def create_new_style(base = {}, &block)
+    klass = ::Class.new(Style, &block)
+    klass.new(create_basic_format(base))
+  end
+  
+  def test_self_style_reader_should_properly_define_a_reading_method
+    style = create_new_style {
+      style_reader :hoge, 'foo'
+    }
+    assert_respond_to style, :hoge
+  end
+  
+  def test_self_style_writer_should_properly_define_a_writing_method
+    style = create_new_style {
+      style_writer :hoge, 'foo'
+    }
+    assert_respond_to style, :hoge=
+  end
+  
+  def test_self_style_accessor_should_properly_defines_reading_and_writing_methods
+    style = create_new_style {
+      style_accessor :hoge, 'foo'
+    }
+    assert_respond_to style, :hoge
+    assert_respond_to style, :hoge=
+  end
+  
+  def test_self_style_accessible_should_add_specified_styles_to_the_accessible_styles_variable
+    style = create_new_style {
+      style_accessible :hoge
+      style_accessible :foo, :bar
+    }
+    assert_equal style.class.accessible_styles, [:hoge, :foo, :bar]
+  end
+  
+  def test_self_accessible_styles_variable_should_not_be_shared_each_SubClasses
+    style1 = create_new_style {
+      style_accessible :hoge, :foo
+    }
+    style2 = create_new_style {
+      style_accessible :bar, :fuga
+    }
+    assert_equal style1.class.accessible_styles, [:hoge, :foo]
+  end
+  
+  def test_self_accessible_styles_variable_should_be_inherited_to_SubClass
+    super_klass = ::Class.new(Style) {
+      style_accessible :hoge, :foo
+    }
+    sub_klass = ::Class.new(super_klass)
+    
+    assert_equal sub_klass.accessible_styles, super_klass.accessible_styles
+  end
+  
+  def test_self_accessible_styles_variables_of_SubClass_should_not_interfere_mutually
+    super_klass = ::Class.new(Style) {
+      style_accessible :foo, :bar
+    }
+    sub_klass1 = ::Class.new(super_klass)
+    sub_klass2 = ::Class.new(super_klass)
+    
+    refute_same sub_klass1.accessible_styles, sub_klass2.accessible_styles
+  end
+  
+  def test_read_internal_style_should_return_style_of_styles_when_style_is_found_in_styles
+    style = create_style('hoge' => 'base_style')
+    style.write_internal_style('hoge', 'new_style')
+    
+    assert_equal style.read_internal_style('hoge'), 'new_style'
+  end
+  
+  def test_read_internal_style_should_return_style_of_base_when_style_is_not_found_in_styles
+    style = create_style('hoge' => 'base_style')
+    assert_equal style.read_internal_style('hoge'), 'base_style'
+  end
+  
+  def test_write_internal_style_should_properly_set_style_to_the_styles
+    style = create_style({})
+    style.write_internal_style('hoge', 'hoge_style')
+    
+    assert_equal style.styles['hoge'], 'hoge_style'
+  end
+  
+  def test_finalized_svg_attributes_should_return_the_Hash_of_having_combined_styles_and_base
+    style = create_style('hoge' => 'base_hoge_style',
+                         'foo'  => 'base_foo_style')
+    style.write_internal_style('hoge', 'modified_hoge_style')
+    
+    assert_equal style.finalized_svg_attributes.values_at('hoge', 'foo'),
+                 ['modified_hoge_style', 'base_foo_style']
+  end
+  
+  def test_finalized_svg_attributes_should_return_a_base_when_styles_is_empty
+    style = create_style
+    assert_equal style.finalized_svg_attributes, style.instance_variable_get(:@base_styles)
+  end
+  
+  def test_finalized_svg_attributes_should_return_a_cloned_base_when_styles_is_empty
+    style = create_style
+    refute_same style.finalized_svg_attributes, style.instance_variable_get(:@base_styles)
+  end
+  
+  def test_finalized_svg_attributes_should_return_same_value_constantly
+    style = create_style('hoge' => 'hoge_style')
+    style.write_internal_style('foo', 'foo_style')
+    
+    assert_same style.finalized_svg_attributes,
+                style.finalized_svg_attributes
+  end
+  
+  def test_svg_attrs_should_operate_like_a_finalized_svg_attributes
+    style = create_style('hoge' => 'hoge_style',
+                         'foo'  => 'foo_style')
+    style.write_internal_style('foo', 'overwrite_foo_style')
+    
+    assert_same style.finalized_svg_attributes, style.svg_attrs
+  end
+  
+  def test_has_style_asker_should_return_true_when_specified_style_method_is_accessible
+    style = create_new_style {
+      style_accessible :hoge, :foo
+    }
+    assert_equal style.has_style?(:foo), true
+  end
+  
+  def test_has_style_asker_should_return_false_when_specified_style_method_is_not_accessible
+    style = create_new_style {
+      style_accessible :foo
+    }
+    assert_equal style.has_style?(:hoge), false
+  end
+  
+  def test_verify_style_value_should_raise_when_value_is_not_included_in_list
+    assert_raises ArgumentError do
+      create_style.send(:verify_style_value, :invalid, [:hoge, :foo, :bar])
+    end
+  end
+  
+  def test_verify_style_value_should_not_raise_when_value_is_found_in_list
+    create_style.send(:verify_style_value, :valid, [:hoge, :valid, :foo])
+  rescue ArgumentError
+    flunk
+  end
+  
+  def test_reader_method_caller_should_properly_delegate_to_real_method
+    style = create_new_style('hoge_style' => 'hoge_style_value') {
+      style_accessible :hoge
+      style_reader :hoge, 'hoge_style'
+    }
+    assert_equal style[:hoge], 'hoge_style_value'
+  end
+  
+  def test_writer_method_caller_should_properly_delegate_to_real_method
+    style = create_new_style {
+      style_accessible :hoge
+      style_accessor :hoge, 'hoge_style'
+    }
+    style[:hoge] = 'hoge_style_value'
+    assert_equal style.hoge, 'hoge_style_value'
+  end
+  
+  def test_reader_method_caller_should_raise_when_style_is_not_accessible
+    assert_raises ThinReports::Errors::UnknownShapeStyleName do
+      create_new_style[:unknown]
+    end
+  end
+  
+  def test_writer_method_caller_should_raise_when_style_is_not_accessible
+    assert_raises ThinReports::Errors::UnknownShapeStyleName do
+      create_new_style[:unknown] = 'value'
+    end
+  end
+  
+  def test_copy_should_return_the_instance_of_the_same_class_as_itself
+    style = create_style
+    assert_instance_of Style, style.copy
+  end
+  
+  def test_styles_of_copied_style_should_not_same_the_styles_of_original
+    style = create_style
+    refute_same style.styles, style.copy.styles
+  end
+  
+  def test_styles_of_copied_style_should_equal_the_style_of_original
+    style = create_style
+    style.write_internal_style('foo', 'foo_value')
+    assert_equal style.styles['foo'], style.copy.styles['foo']
+  end
+  
+  def test_identifier_should_return_empty_string_when_the_style_is_not_set
+    style = create_style
+    assert_equal style.identifier, ''
+  end
+  
+  def test_identifier_should_return_the_same_as_hash_value_of_styles_when_style_is_set_something
+    style = create_style
+    style.write_internal_style('foo', 'foo_value')
+    
+    assert_equal style.identifier, style.styles.hash.to_s
+  end
+end

data/test/unit/core/shape/styles/test_basic.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Style::TestBasic < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  def create_basic_style(format_config = {})
+    format = ThinReports::Core::Shape::Basic::Format.new(format_config)
+    ThinReports::Core::Shape::Style::Basic.new(format)
+  end
+  
+  def test_visible_should_return_visibility_of_format_as_default
+    style = create_basic_style('display' => 'false')
+    assert_equal style.visible, false
+  end
+  
+  def test_visible_should_properly_set_visibility
+    style = create_basic_style('display' => 'false')
+    style.visible = true
+    
+    assert_equal style.visible, true
+  end
+end

data/test/unit/core/shape/styles/test_graphic.rb

@@ -0,0 +1,69 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Style::TestGraphic < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  def create_graphic_style
+    format = ThinReports::Core::Shape::Basic::Format.new({})
+    ThinReports::Core::Shape::Style::Graphic.new(format)
+  end
+  
+  def test_border_color_should_properly_set_to_internal_styles_as_stroke_style
+    style = create_graphic_style
+    style.border_color = '#ff0000'
+    
+    assert_equal style.styles['stroke'], '#ff0000'
+  end
+  
+  def test_border_width_should_properly_set_to_internal_styles_as_stroke_width_style
+    style = create_graphic_style
+    style.border_width = 1
+    
+    assert_equal style.styles['stroke-width'], 1
+  end
+  
+  def test_border_width_should_set_stroke_opacity_to_1_when_width_is_not_zero
+    style = create_graphic_style
+    style.border_width = 5
+    
+    assert_equal style.styles['stroke-opacity'], '1'
+  end
+  
+  def test_fill_color_should_properly_set_to_internal_styles_as_fill_style
+    style = create_graphic_style
+    style.fill_color = '#0000ff'
+    
+    assert_equal style.styles['fill'], '#0000ff'
+  end
+  
+  def test_fill_should_operate_like_the_fill_color_method
+    style = create_graphic_style
+    style.fill = '#ff0000'
+    
+    assert_same style.fill_color, style.fill
+  end
+  
+  def test_stroke_should_operate_like_the_border_width_method
+    style = create_graphic_style
+    style.stroke = 5
+    
+    assert_same style.border_width, style.stroke
+  end
+  
+  def test_border_should_return_an_Array_included_border_width_and_border_color
+    style = create_graphic_style
+    style.border_width = 1
+    style.border_color = '#ff0000'
+    
+    assert_equal style.border, [style.border_width, style.border_color]
+  end
+  
+  def test_border_should_properly_set_both_border_width_and_border_color_from_the_specified_array_argument
+    style = create_graphic_style
+    style.border = [5, '#000000']
+    
+    assert_equal style.border, [5, '#000000']
+  end
+end

data/test/unit/core/shape/styles/test_text.rb

@@ -0,0 +1,318 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Style::TestText < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  def create_format(format = {})
+    ThinReports::Core::Shape::Text::Format.new(format)
+  end
+  
+  def create_text_style(format = nil)
+    format ||= create_format
+    ThinReports::Core::Shape::Style::Text.new(format)
+  end
+  
+  def test_bold_should_return_true_when_font_weight_property_of_format_is_bold
+    format = create_format('svg' => {'attrs' => {'font-weight' => 'bold'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.bold, true
+  end
+  
+  def test_bold_should_return_false_when_font_weight_property_of_format_is_not_bold
+    format = create_format('svg' => {'attrs' => {'font-weight' => 'normal'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.bold, false
+  end
+  
+  def test_bold_should_set_normal_to_font_weight_style_when_value_is_false
+    style = create_text_style
+    style.bold = false
+    
+    assert_equal style.styles['font-weight'], 'normal'
+  end
+  
+  def test_bold_should_set_bold_to_font_weight_style_when_value_is_true
+    style = create_text_style
+    style.bold = true
+    
+    assert_equal style.styles['font-weight'], 'bold'
+  end
+  
+  def test_bold_should_return_true_when_font_weight_of_internal_style_is_bold
+    style = create_text_style
+    style.styles['font-weight'] = 'bold'
+    
+    assert_equal style.bold, true
+  end
+  
+  def test_bold_should_return_false_when_font_weight_of_internal_style_is_not_bold
+    style = create_text_style
+    style.styles['font-weight'] = 'normal'
+    
+    assert_equal style.bold, false
+  end
+  
+  def test_italic_should_return_true_when_font_style_property_of_format_is_italic
+    format = create_format('svg' => {'attrs' => {'font-style' => 'italic'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.italic, true
+  end
+  
+  def test_italic_should_return_false_when_font_style_property_of_format_is_not_italic
+    format = create_format('svg' => {'attrs' => {'font-style' => 'normal'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.italic, false
+  end
+  
+  def test_italic_should_set_normal_to_font_style_style_when_value_is_false
+    style = create_text_style
+    style.italic = false
+    
+    assert_equal style.styles['font-style'], 'normal'
+  end
+  
+  def test_italic_should_set_italic_to_font_style_style_when_value_is_true
+    style = create_text_style
+    style.italic = true
+    
+    assert_equal style.styles['font-style'], 'italic'
+  end
+  
+  def test_italic_should_return_false_when_font_style_of_internal_style_is_not_italic
+    style = create_text_style
+    style.styles['font-style'] = 'normal'
+    
+    assert_equal style.italic, false
+  end
+  
+  def test_italic_should_return_true_when_font_style_of_internal_style_is_italic
+    style = create_text_style
+    style.styles['font-style'] = 'italic'
+    
+    assert_equal style.italic, true
+  end
+  
+  def test_underline_should_return_true_when_underline_is_included_in_text_decoration_property_of_format
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'underline line-through'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.underline, true
+  end
+  
+  def test_underline_should_return_false_when_underline_is_not_included_in_text_decoration_property_of_format
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'line-through'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.underline, false
+  end
+  
+  def test_underline_should_return_true_when_underline_is_included_in_text_decoration_of_internal_style
+    style = create_text_style
+    style.styles['text-decoration'] = 'underline line-through'
+    
+    assert_equal style.underline, true
+  end
+  
+  def test_underline_should_return_false_when_underline_is_not_included_in_text_decoration_of_internal_style
+    style = create_text_style
+    style.styles['text-decoration'] = 'none'
+    
+    assert_equal style.underline, false
+  end
+  
+  def test_underline_should_include_underline_in_text_decoration_when_value_is_true
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'line-through'}})
+    style  = create_text_style(format)
+    style.underline = true
+    
+    assert_includes style.styles['text-decoration'], 'underline'
+  end
+  
+  def test_underline_should_remove_underline_from_text_decoration_when_value_is_false
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'underline line-through'}})
+    style  = create_text_style(format)
+    style.underline = false
+    
+    refute_includes style.styles['text-decoration'], 'underline'
+  end
+  
+  def test_linethrough_should_return_true_when_line_through_is_included_in_text_decoration_property_of_format
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'underline line-through'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.linethrough, true
+  end
+  
+  def test_linethrough_should_return_false_when_line_through_is_not_included_in_text_decoration_property_of_format
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'underline'}})
+    style  = create_text_style(format)
+    
+    assert_equal style.linethrough, false
+  end
+  
+  def test_linethrough_should_return_true_when_line_through_is_included_in_text_decoration_of_internal_style
+    style = create_text_style
+    style.styles['text-decoration'] = 'underline line-through'
+    
+    assert_equal style.linethrough, true
+  end
+  
+  def test_linethrough_should_return_false_when_line_through_is_not_included_in_text_decoration_of_internal_style
+    style = create_text_style
+    style.styles['text-decoration'] = 'underline'
+    
+    assert_equal style.linethrough, false
+  end
+  
+  def test_linethrough_should_include_line_through_in_text_decoration_when_value_is_true
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'none'}})
+    style  = create_text_style(format)
+    style.linethrough = true
+    
+    assert_includes style.styles['text-decoration'], 'line-through'
+  end
+  
+  def test_linethrough_should_remove_line_through_from_text_decoration_when_value_is_false
+    format = create_format('svg' => {'attrs' => {'text-decoration' => 'underline line-through'}})
+    style  = create_text_style(format)
+    style.linethrough = false
+    
+    refute_includes style.styles['text-decoration'], 'line-through'
+  end
+  
+  def test_text_decoration_should_return_none
+    assert_equal create_text_style.send(:text_decoration, false, false), 'none'
+  end
+  
+  def test_text_decoration_should_return_underline
+    assert_equal create_text_style.send(:text_decoration, true, false), 'underline'
+  end
+  
+  def test_text_decoration_should_return_line_through
+    assert_equal create_text_style.send(:text_decoration, false, true), 'line-through'
+  end
+  
+  def test_text_decoration_should_return_underline_line_through
+    assert_equal create_text_style.send(:text_decoration, true, true), 'underline line-through'
+  end
+  
+  def test_interface_text_align_should_return_Symbol_left_when_value_is_undefined
+    assert_equal create_text_style.send(:interface_text_align, nil), :left
+  end
+  
+  def test_interface_text_align_should_return_Symbol_left_when_value_is_String_start
+    assert_equal create_text_style.send(:interface_text_align, 'start'), :left
+  end
+  
+  def test_interface_text_align_should_return_Symbol_left_when_value_is_unknown_align_type
+    assert_equal create_text_style.send(:interface_text_align, 'unknown'), :left
+  end
+  
+  def test_interface_text_align_should_return_Symbol_center_when_value_is_String_middle
+    assert_equal create_text_style.send(:interface_text_align, 'middle'), :center
+  end
+  
+  def test_interface_text_align_should_return_Symbol_right_when_value_is_String_end
+    assert_equal create_text_style.send(:interface_text_align, 'end'), :right
+  end
+  
+  def test_internal_text_align_should_return_nil_when_value_is_unknown
+    assert_equal create_text_style.send(:internal_text_align, :unknown), nil
+  end
+  
+  def test_internal_text_align_should_return_String_start_when_value_is_Symbol_left
+    assert_equal create_text_style.send(:internal_text_align, :left), 'start'
+  end
+  
+  def test_internal_text_align_should_return_String_middle_when_value_is_Symbol_center
+    assert_equal create_text_style.send(:internal_text_align, :center), 'middle'
+  end
+  
+  def test_internal_text_align_should_return_String_end_when_value_is_Symbol_right
+    assert_equal create_text_style.send(:internal_text_align, :right), 'end'
+  end
+  
+  def test_align_should_properly_return_align_type_with_reference_to_text_anchor_property_of_format
+    result = []
+    
+    format_left   = create_format('svg' => {'attrs' => {'text-anchor' => 'start'}})
+    format_center = create_format('svg' => {'attrs' => {'text-anchor' => 'middle'}})
+    format_right  = create_format('svg' => {'attrs' => {'text-anchor' => 'end'}})
+    
+    result << create_text_style(format_left).align
+    result << create_text_style(format_center).align
+    result << create_text_style(format_right).align
+    
+    assert_equal result, [:left, :center, :right]
+  end
+  
+  def test_copy_should_properly_copy_the_valign_property_of_the_original
+    style = create_text_style
+    style.valign = :center
+    
+    assert_equal style.copy.valign, :center
+  end
+  
+  def test_align_should_property_return_align_type_with_reference_to_text_anchor_of_internal_style
+    style = create_text_style
+    style.styles['text-anchor'] = 'middle'
+    
+    assert_equal style.align, :center
+  end
+  
+  def test_align_should_set_interface_align_type_to_text_anchor
+    style = create_text_style
+    style.align = :right
+    
+    assert_equal style.styles['text-anchor'], 'end'
+  end
+  
+  def test_align_should_raise_when_the_specified_type_is_unknown
+    assert_raises ArgumentError do
+      create_text_style.align = :unknown
+    end
+  end
+  
+  def test_valign_should_return_top_when_valign_of_format_is_blank
+    assert_equal create_text_style.valign, :top
+  end
+  
+  def test_valign_should_return_valign_type_of_format_as_default
+    format = create_format('valign' => 'bottom')
+    style  = create_text_style(format)
+    
+    assert_equal style.valign, :bottom
+  end
+  
+  def test_valign_should_properly_set_valign_type
+    style = create_text_style
+    style.valign = :center
+    
+    assert_equal style.valign, :center
+  end
+  
+  def test_valign_should_raise_when_the_specified_type_is_unknown
+    assert_raises ArgumentError do
+      create_text_style.valign = :unknonw
+    end
+  end
+  
+  def test_identifier_should_return_the_same_value_as_create_identifier_method_when_valign_has_not_been_changed
+    style = create_text_style
+    assert_equal style.identifier, style.send(:create_identifier, style.styles)
+  end
+  
+  def test_identifier_should_return_the_value_which_added_valign_to_the_value_of_create_identifier_when_valign_has_been_changed
+    style = create_text_style
+    style.valign = :bottom
+    
+    assert_equal style.identifier,
+                 style.send(:create_identifier, style.styles) + 'bottom'
+  end
+end