thinreports 0.6.0.pre3

data/test/unit/core/shape/tblock/formatter/test_basic.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::Formatter::TestBasic < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Basic
+  
+  def test_apply_simple_format
+    format = flexmock(:format_base => 'Hello {value}!')
+    
+    assert_equal Formatter.new(format).apply('ThinReports'),
+                 'Hello ThinReports!'
+  end
+  
+  def test_apply_multiple_format
+    format = flexmock(:format_base => 'Hello {value}! And good bye {value}.')
+    
+    assert_equal Formatter.new(format).apply('ThinReports'),
+                 'Hello ThinReports! And good bye ThinReports.'
+  end
+end

data/test/unit/core/shape/tblock/formatter/test_datetime.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::Formatter::TestDatetime < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Datetime
+  
+  def setup
+    @datetime_format = '%Y/%m/%d %H:%M:%S'
+    @time            = Time.now
+
+    @format = flexmock(:format_base => '', 
+                       :format_datetime_format => @datetime_format)
+  end
+  
+  def test_apply_datetime_format_without_basic_format
+    formatter = Formatter.new(@format)
+    
+    assert_equal formatter.apply(@time), @time.strftime(@datetime_format)
+  end
+  
+  def test_apply_datetime_format_with_basic_format
+    # Partial mock
+    format = flexmock(@format, :format_base => 'Now: {value}')
+    
+    formatter = Formatter.new(format)
+    
+    assert_equal formatter.apply(@time),
+                 "Now: #{@time.strftime(@datetime_format)}"
+  end
+  
+  def test_not_apply_datetime_format_and_return_raw_value
+    # When value is invalid
+    formatter = Formatter.new(@format)
+    
+    assert_same formatter.apply(val = 'invalid value'), val
+    assert_same formatter.apply(val = 123456), val
+    
+    # When format is empty
+    format = flexmock(@format, :format_datetime_format => '')
+    
+    assert_same formatter.apply(@time), @time
+  end
+end

data/test/unit/core/shape/tblock/formatter/test_number.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::Formatter::TestNumber < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Number
+  
+  def init_formatter(expect_formats)
+    format = flexmock({:format_base => '',
+                       :format_number_precision => nil,
+                       :format_number_delimiter => nil}.merge(expect_formats))
+    Formatter.new(format)
+  end
+  
+  def test_apply_precision_formats
+    # When precision is 2
+    formatter = init_formatter(:format_number_precision => 2)
+    
+    assert_equal formatter.apply(1.005), '1.01'
+    assert_equal formatter.apply(1.004), '1.00'
+    assert_equal formatter.apply(1), '1.00'
+    # With String value
+    assert_equal formatter.apply('999.999'), '1000.00'
+    assert_equal formatter.apply('-999.999'), '-1000.00'
+    assert_equal formatter.apply('9'), '9.00'
+    # Cannot apply, Return the raw value
+    assert_equal formatter.apply('invalid value'), 'invalid value'
+    
+    # When precision is 0
+    formatter = init_formatter(:format_number_precision => 0)
+    
+    assert_equal formatter.apply(1.5), '2'
+  end
+  
+  def test_apply_precision_format_with_basic_format
+    formatter = init_formatter(:format_base => '$ {value}',
+                               :format_number_precision => 0)
+    
+    assert_equal formatter.apply(199.5), '$ 200'
+  end
+  
+  def test_apply_delimiter_formats
+    # When delimiter is ','
+    formatter = init_formatter(:format_number_delimiter => ',')
+    
+    assert_equal formatter.apply(1000000), '1,000,000'
+    assert_equal formatter.apply(-1000000), '-1,000,000'
+    assert_equal formatter.apply('1000.0'), '1,000.0'
+    assert_equal formatter.apply('-1000.0'), '-1,000.0'
+    # Cannot apply, Return the raw value
+    assert_equal formatter.apply('invalid value'), 'invalid value'
+    
+    # When delimiter is whitespace
+    formatter = init_formatter(:format_number_delimiter => ' ')
+    
+    assert_equal formatter.apply(99999), '99 999'
+  end
+  
+  def test_apply_delimiter_format_with_basic_format
+    formatter = init_formatter(:format_base => '￥{value}',
+                               :format_number_delimiter => ',')
+    
+    assert_equal formatter.apply(199800), '￥199,800'
+  end
+  
+  def test_apply_all_format
+    formatter = init_formatter(:format_base => '-- {value} --',
+                               :format_number_delimiter => ',',
+                               :format_number_precision => 2)
+
+    assert_equal formatter.apply(95618.88567), '-- 95,618.89 --'
+  end
+end

data/test/unit/core/shape/tblock/formatter/test_padding.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::Formatter::TestPadding < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Padding
+  
+  def init_formatter(expect_formats)
+    format = flexmock({:format_base           => nil,
+                       :format_padding_length => 0,
+                       :format_padding_char   => nil,
+                       :format_padding_rdir?  => false}.merge(expect_formats))
+    Formatter.new(format)
+  end
+  
+  def test_apply_padding_formats
+    formatter = init_formatter(:format_padding_length => 5,
+                               :format_padding_char   => '0')
+    
+    assert_equal formatter.apply(1), '00001'
+    assert_equal formatter.apply('日本語'), '00日本語'
+    
+    # Text length is longer than the specified length.
+    assert_equal formatter.apply('1234567'), '1234567'
+    
+    # When direction is right
+    formatter = init_formatter(:format_padding_length => 5,
+                               :format_padding_char   => '0',
+                               :format_padding_rdir?  => true)
+    
+    assert_equal formatter.apply(123), '12300'
+  end
+  
+  def test_apply_padding_format_with_basic_format
+    formatter = init_formatter(:format_base           => '[{value}]',
+                               :format_padding_length => 10,
+                               :format_padding_char   => ' ')
+
+    assert_equal formatter.apply('ABC'), '[       ABC]'
+  end
+  
+  def test_return_raw_value_when_length_is_0
+    formatter = init_formatter(:format_padding_length => 0,
+                               :format_padding_char   => '0')
+    
+    assert_same formatter.apply(v = 123), v
+    
+    # But apply only basic format if have basic-format.
+    formatter = init_formatter(:format_base           => '<{value}>',
+                               :format_padding_length => 0,
+                               :format_padding_char   => '0')
+    
+    assert_equal formatter.apply(123), '<123>'
+  end
+  
+  def test_return_raw_value_when_char_is_empty
+    formatter = init_formatter(:format_padding_length => 10,
+                               :format_padding_char   => '')
+    
+    assert_same formatter.apply(v = '1'), v
+
+    # But apply only basic format if have basic-format.
+    formatter = init_formatter(:format_base           => '<{value}>',
+                               :format_padding_length => 0,
+                               :format_padding_char   => '0')
+    
+    assert_equal formatter.apply('1'), '<1>'
+  end
+end

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

@@ -0,0 +1,125 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  TEST_TBLOCK_FORMAT = {
+    "type" => "s-tblock",
+    "id" => "block_1", 
+    "display" => "true", 
+    "multiple" => "false",
+    "box" => {
+      "x" => 100.0,
+      "y" => 100.0,
+      "width" => 100.0,
+      "height" => 100.0
+    },
+    "format" => {
+      "base" => "￥{value}", 
+      "type" => "number", 
+      "number" => {
+        "delimiter" => ",", 
+        "precision" => 1
+      }
+    }, 
+    "value" => "", 
+    "ref-id" => "", 
+    "svg" => {
+      "tag" => "text", 
+      "attrs" => {
+        "x" => 200.1, 
+        "y" => 65.6, 
+        "text-anchor" => "end", 
+        "xml:space" => "preserve", 
+        "fill" => "#000000", 
+        "fill-opacity" => "1", 
+        "font-size" => "12", 
+        "font-family" => "\uFF2D\uFF33 \u30B4\u30B7\u30C3\u30AF", 
+        "font-weight" => "bold", 
+        "font-style" => "normal", 
+        "text-decoration" => "none", 
+        "clip-path" => "url(#_svgdef_0)"
+      }
+    }
+  }
+
+  def test_build
+    build_format
+  rescue
+    flunk exception_details(e, 'Building failed.')
+  end
+  
+  def test_config_readers
+    format = format(TEST_TBLOCK_FORMAT)
+    
+    assert_equal format.value, ''
+    assert_equal format.ref_id, ''
+    assert_equal format.format_base, '￥{value}'
+    assert_equal format.format_type, 'number'
+    assert_instance_of ::Hash, format.box
+    assert_equal format.box['x'], 100.0
+    
+    # Methods reference to unknown value returns a nil value
+    assert_nil format.format_datetime_format
+    assert_nil format.format_padding_char
+    assert_nil format.format_padding_dir
+    
+    # In face, #format_padding_length returns a nil value
+    assert_equal format.format_padding_length, 0
+
+    assert_equal format.format_padding_rdir?, false
+    assert_equal format.has_format?, true
+    assert_equal format.has_reference?, false
+    assert_equal format.multiple?, false
+  end
+  
+  def test_multiple?
+    assert format('multiple' => 'true').multiple?
+    refute format('multiple' => 'false').multiple?
+  end
+  
+  def test_format_padding_rdir?
+    data = {'format' => {'padding' => {'direction' => 'L'}}}
+    
+    refute format(data).format_padding_rdir?
+    
+    data['format']['padding']['direction'] = 'R'
+    assert format(data).format_padding_rdir?
+  end
+  
+  def test_format_padding_length
+    data = {'format' => {'padding' => {'length' => '0'}}}
+    
+    assert_equal format(data).format_padding_length, 0
+    
+    data['format']['padding']['length'] = '10'
+    assert_equal format(data).format_padding_length, 10
+  end
+  
+  def test_has_format?
+    data = {'format' => {'type' => ''}}
+    
+    refute format(data).has_format?
+    
+    data['format']['type'] = 'number'
+    assert format(data).has_format?
+    
+    data['format']['type'] = 'unknown'
+    refute format(data).has_format?
+  end
+  
+  def test_has_reference?
+    refute format('ref-id' => '').has_reference?
+    assert format('ref-id' => 'ref_tblock_1').has_reference?
+  end
+  
+  def build_format
+    ThinReports::Core::Shape::Tblock::Format.build(TEST_TBLOCK_FORMAT)
+  end
+  
+  def format(data)
+    ThinReports::Core::Shape::Tblock::Format.new(data)
+  end
+end

data/test/unit/core/shape/tblock/test_formatter.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::TestFormatter < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Formatter = ThinReports::Core::Shape::Tblock::Formatter
+  
+  def test_initialize_formatter_by_type
+    assert_instance_of Formatter::Basic,
+      Formatter.setup( flexmock(:format_type => '') )
+    
+    assert_instance_of Formatter::Number,
+      Formatter.setup( flexmock(:format_type => 'number') )
+      
+    assert_instance_of Formatter::Datetime,
+      Formatter.setup( flexmock(:format_type => 'datetime') )
+    
+    assert_instance_of Formatter::Padding,
+      Formatter.setup( flexmock(:format_type => 'padding') )
+      
+    assert_raises ThinReports::Errors::UnknownFormatterType do
+      Formatter.setup( flexmock(:format_type => 'unknown') )
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::TestInterface < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  Tblock = ThinReports::Core::Shape::Tblock
+  
+  def setup
+    @interface = Tblock::Interface.new(flexmock('parent'), flexmock('format'))
+  end
+  
+  def test_value_work_as_getter_when_receive_no_arguments
+    flexmock(@interface.internal).should_receive(:read_value).
+        and_return('value').once
+    
+    assert_equal @interface.value, 'value'
+  end
+  
+  def test_value_work_as_setter_when_receive_an_just_one_argument
+    flexmock(@interface.internal).should_receive(:write_value).once
+    
+    @interface.value('any value')
+  end
+  
+  def test_value_raise_error_when_receive_more_than_two
+    assert_raises ArgumentError do
+      @interface.value('arg1', 'arg2')
+    end
+  end
+  
+  def test_set
+    flexmock(@interface).
+        should_receive(:value).once.
+        should_receive(:styles).once
+    
+    @interface.set('value', :fill => 'red')
+  end
+end

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

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Tblock::TestInternal < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  Tblock = ThinReports::Core::Shape::Tblock
+  
+  def test_read_value_return_the_format_value
+    format = flexmock('format')
+    format.should_receive(:value => 'format value').times(2)
+    format.should_receive(:has_reference? => false)
+    
+    internal = init_internal(format)
+    
+    assert_equal internal.read_value, 'format value'
+    assert_equal internal.value, 'format value'
+  end
+  
+  def test_read_value_return_the_value_of_referenced_shape
+    format = flexmock('format')
+    format.should_receive(:has_reference? => true)
+    format.should_receive(:ref_id => 'dummy')
+    
+    internal = init_internal(format)
+    
+    assert_equal internal.read_value, 'referenced value'
+    assert_equal internal.value, 'referenced value'
+  end
+  
+  def test_read_value_return_the_value_stored_in_states
+    format = flexmock('format')
+    format.should_receive(:has_reference? => false)
+    
+    internal = init_internal(format)
+    internal.states[:value] = 'any value'
+    
+    assert_equal internal.read_value, 'any value'
+    assert_equal internal.value, 'any value'
+  end
+  
+  def test_write_value
+    format = flexmock('format')
+    format.should_receive(:has_reference? => false)
+    
+    internal = init_internal(format)
+    internal.write_value('value written')
+    
+    assert_equal internal.value, 'value written'
+  end
+  
+  def test_write_value_show_warnings_when_has_reference
+    format = flexmock('format')
+    format.should_receive(:has_reference? => true,
+                          :ref_id => 'ref id',
+                          :id => 'id')
+    out, err = capture_io do
+      init_internal(format).write_value('value written')
+    end
+    assert_equal err.chomp, 'The set value is not reflected, ' +
+                            "Because 'id' refers to 'ref id'."
+  end
+  
+  def test_real_value_return_the_formatted_value
+    format = flexmock('format')
+    format.should_receive(:has_format? => true,
+                          :multiple?   => false)
+    
+    internal = init_internal(format)
+    flexmock(internal, :read_value => 'dummy')
+    
+    assert_equal internal.real_value, 'formatted value'
+  end
+  
+  def test_real_value_return_the_raw_value_when_has_not_format
+    format = flexmock('format')
+    format.should_receive(:has_format? => false,
+                          :multiple?   => false)
+    
+    internal = init_internal(format)
+    flexmock(internal, :read_value => 'raw value')
+    
+    assert_equal internal.real_value, 'raw value'
+  end
+  
+  def test_real_value_return_the_raw_value_constantly_when_is_multiple
+    format = flexmock('format')
+    format.should_receive(:has_format? => true,
+                          :multiple?   => true)
+    
+    internal = init_internal(format)
+    flexmock(internal, :read_value => 'raw value')
+    
+    assert_equal internal.real_value, 'raw value'    
+  end
+  
+  def test_format_enabled
+    internal = init_internal(flexmock('format'))
+    internal.format_enabled(true)
+    
+    assert_equal internal.states[:format_enabled], true
+  end
+  
+  def test_format_enabled?
+    internal = init_internal(flexmock(:has_format? => true,
+                                      :multiple?   => false))
+    
+    assert_equal internal.format_enabled?, true
+    
+    internal.format_enabled(false)
+    
+    assert_equal internal.format_enabled?, false
+    
+    flexmock(internal.format, :multiple? => true)
+    internal.format_enabled(true)
+    
+    assert_equal internal.format_enabled?, false
+  end
+  
+  def test_type_of?
+    assert_equal init_internal(flexmock('format')).type_of?(:tblock), true
+  end
+  
+  def init_internal(format)
+    parent = flexmock('parent')
+    parent.should_receive(:item).
+        and_return(flexmock(:value => 'referenced value'))
+    
+    formatter = flexmock('formatter')
+    formatter.should_receive(:apply).
+        and_return('formatted value')
+    
+    flexmock(Tblock::Internal).new_instances.should_receive(:formatter).
+        and_return(formatter)
+    
+    Tblock::Internal.new(parent, format)
+  end
+end