thinreports 0.7.7 → 0.8.0

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

@@ -1,77 +1,77 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::Formatter::TestPadding < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::Formatter::TestPadding < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Padding
-  
+  Formatter = Thinreports::Core::Shape::TextBlock::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))
+    format = stub({ 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_with_left_direction
-    formatter = init_formatter(:format_padding_length => 5,
-                               :format_padding_char   => '0')
-    
+    formatter = init_formatter(format_padding_length: 5,
+                               format_padding_char: '0')
+
     assert_equal formatter.apply(1), '00001'
     assert_equal formatter.apply('日本語'), '00日本語'
   end
-  
+
   def test_apply_padding_formats_should_not_apply_when_character_length_is_short
-    formatter = init_formatter(:format_padding_length => 5,
-                               :format_padding_char   => '0')
-    
+    formatter = init_formatter(format_padding_length: 5,
+                               format_padding_char: '0')
+
     assert_equal formatter.apply('1234567'), '1234567'
   end
-  
+
   def test_apply_padding_formats_with_right_direction
-    formatter = init_formatter(:format_padding_length => 5,
-                               :format_padding_char   => '0',
+    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   => ' ')
+    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')
-    
+    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')
-    
+    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   => '')
-    
+    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')
-    
+    formatter = init_formatter(format_base: '<{value}>',
+                               format_padding_length: 0,
+                               format_padding_char: '0')
+
     assert_equal formatter.apply('1'), '<1>'
   end
-end
+end

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

@@ -1,9 +1,9 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::TextBlock::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
 
   TEST_TBLOCK_FORMAT = {
     "type" => "s-tblock",
@@ -25,7 +25,7 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
         "delimiter" => ",", 
         "precision" => 1
       }
-    }, 
+    },
     "value" => "", 
     "ref-id" => "", 
     "svg" => {
@@ -38,7 +38,7 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
         "fill" => "#000000", 
         "fill-opacity" => "1", 
         "font-size" => "12", 
-        "font-family" => "\uFF2D\uFF33 \u30B4\u30B7\u30C3\u30AF", 
+        "font-family" => "Helvetica", 
         "font-weight" => "bold", 
         "font-style" => "normal", 
         "text-decoration" => "none", 
@@ -52,7 +52,7 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
   rescue => e
     flunk exception_details(e, 'Building failed.')
   end
-  
+
   def test_value_reader_via_TEST_TBLOCK_FORMAT
     assert_equal format(TEST_TBLOCK_FORMAT).value, ''
   end
@@ -161,10 +161,10 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
   end
   
   def build_format
-    ThinReports::Core::Shape::TextBlock::Format.build(TEST_TBLOCK_FORMAT)
+    Thinreports::Core::Shape::TextBlock::Format.build(TEST_TBLOCK_FORMAT)
   end
   
   def format(data)
-    ThinReports::Core::Shape::TextBlock::Format.new(data)
+    Thinreports::Core::Shape::TextBlock::Format.new(data)
   end
 end

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

@@ -1,28 +1,28 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::TestFormatter < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::TestFormatter < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Formatter = ThinReports::Core::Shape::TextBlock::Formatter
-  
+  Formatter = Thinreports::Core::Shape::TextBlock::Formatter
+
   def test_initialize_formatter_by_type
     assert_instance_of Formatter::Basic,
-      Formatter.setup( flexmock(:format_type => '') )
-    
+      Formatter.setup( stub(format_type: '') )
+
     assert_instance_of Formatter::Number,
-      Formatter.setup( flexmock(:format_type => 'number') )
-      
+      Formatter.setup( stub(format_type: 'number') )
+
     assert_instance_of Formatter::Datetime,
-      Formatter.setup( flexmock(:format_type => 'datetime') )
-    
+      Formatter.setup( stub(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') )
+      Formatter.setup( stub(format_type: 'padding') )
+
+    assert_raises Thinreports::Errors::UnknownFormatterType do
+      Formatter.setup( stub(format_type: 'unknown') )
     end
   end
-end
+end

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

@@ -1,46 +1,63 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::TestInterface < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::TestInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  TextBlock = ThinReports::Core::Shape::TextBlock
-  
+  TextBlock = Thinreports::Core::Shape::TextBlock
+
   def create_interface(format_config = {})
-    TextBlock::Interface.new(flexmock('parent'),
-                             TextBlock::Format.new(format_config))
+    report = new_report 'layout_text1'
+    parent = report.start_new_page
+
+    TextBlock::Interface.new parent, TextBlock::Format.new(format_config)
   end
-  
+
   def test_format_enabled_asker_should_operate_as_delegator_of_internal
     tblock = create_interface('format' => {'type' => 'datetime'})
     assert_equal tblock.format_enabled?, tblock.internal.format_enabled?
   end
-  
+
   def test_format_enabled_should_properly_set_value_to_internal
     tblock = create_interface('format' => {'type' => 'number'})
     tblock.format_enabled(false)
-    
+
     assert_equal tblock.internal.format_enabled?, false
   end
-  
+
   def test_set_should_properly_set_a_value
     tblock = create_interface
-    tblock.set(1000, :visible => false)
-    
+    tblock.set(1000, visible: false)
+
     assert_equal tblock.value, 1000
   end
-  
+
   def test_set_should_properly_set_styles
     tblock = create_interface
-    tblock.set(1000, :color  => '#ff0000',
-                     :bold   => true,
-                     :italic => true)
-    
+    tblock.set(1000, color: '#ff0000',
+                     bold: true,
+                     italic: true)
+
     assert_equal [tblock.style(:color),
                   tblock.style(:bold),
                   tblock.style(:italic)],
                  ['#ff0000', true, true]
   end
-end
+
+  def test_value=
+    report = new_report 'layout_block.tlf'
+    page = report.start_new_page
+
+    page.item(:text_block1).value = 'foo'
+    assert_equal 'foo', page.item(:text_block1).value
+
+    page.item(:text_block1).value += 'bar'
+    assert_equal 'foobar', page.item(:text_block1).value
+
+    page.item(:text_block1).value = 1000
+    page.item(:text_block1).value += 999
+    assert_equal 1999, page.item(:text_block1).value
+  end
+end

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

@@ -1,15 +1,15 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  TextBlock = ThinReports::Core::Shape::TextBlock
-  
+  TextBlock = Thinreports::Core::Shape::TextBlock
+
   def create_parent
-    report = create_basic_report('basic_layout1.tlf')
+    report = new_report('layout_text1.tlf')
     report.start_new_page do |page|
       # Add to force TextBlock shape.
       page.manager.format.shapes[:foo] = TextBlock::Format.new('type' => 's-tblock',
@@ -18,111 +18,111 @@ class ThinReports::Core::Shape::TextBlock::TestInternal < MiniTest::Unit::TestCa
       page.item(:foo).value('foo value')
     end
   end
-  
+
   def create_internal(format_config = {})
     TextBlock::Internal.new(create_parent, TextBlock::Format.new(format_config))
   end
-  
+
   def test_multiple_asker_should_operate_as_delegator_of_format
     tblock = create_internal('multiple' => 'true')
     assert_equal tblock.multiple?, tblock.format.multiple?
   end
-  
+
   def test_style_should_return_the_instance_of_Style_Text
-    assert_instance_of ThinReports::Core::Shape::Style::Text, create_internal.style
+    assert_instance_of Thinreports::Core::Shape::Style::Text, create_internal.style
   end
-  
+
   def test_read_value_should_return_the_format_value_as_default
     tblock = create_internal('value' => 'default value')
     assert_equal tblock.read_value, 'default value'
   end
-  
+
   def test_read_value_should_return_the_value_of_referenced_shape
     tblock = create_internal('ref-id' => 'foo')
     assert_equal tblock.read_value, 'foo value'
   end
-  
+
   def test_read_value_should_return_the_value_stored_in_states
     tblock = create_internal
     tblock.states[:value] = 'value in states'
-    
+
     assert_equal tblock.read_value, 'value in states'
   end
-  
+
   def test_write_value_should_properly_set_the_specified_value_to_states
     tblock = create_internal
     tblock.write_value(1000)
-    
+
     assert_equal tblock.states[:value], 1000
   end
-  
+
   def test_write_value_should_show_warnings_when_tblock_has_reference
     tblock = create_internal('id' => 'bar', 'ref-id' => 'foo')
     out, err = capture_io do
       tblock.write_value('value')
     end
     assert_equal err.chomp, 'The set value was not saved, ' +
-                            "Because 'bar' refers to 'foo'."
+                            "Because 'bar' has reference to 'foo'."
   end
-  
+
   def test_real_value_should_return_the_formatted_value_when_tblock_has_any_format
     tblock = create_internal('format' => {'type'     => 'datetime',
                                           'datetime' => {'format' => '%Y/%m/%d'}})
     tblock.write_value(value = Time.now)
-    
+
     assert_equal tblock.real_value, value.strftime('%Y/%m/%d')
   end
-  
+
   def test_real_value_should_return_the_raw_value_when_tblock_has_no_format
     tblock = create_internal
     tblock.write_value('any value')
-    
+
     assert_equal tblock.real_value, 'any value'
   end
-  
+
   def test_format_enabled_should_properly_set_value_to_states_as_format_enabled
     tblock = create_internal
     tblock.format_enabled(false)
-    
+
     assert_equal tblock.states[:format_enabled], false
   end
-  
+
   def test_format_enabled_asker_should_return_true_when_format_has_any_type
     tblock = create_internal('format' => {'type' => 'datetime'})
-    
+
     assert_equal tblock.format_enabled?, true
   end
-  
+
   def test_format_enabled_asker_should_return_true_when_base_of_format_has_any_value
     tblock = create_internal('format' => {'base' => '{value}'})
-    
+
     assert_equal tblock.format_enabled?, true
   end
-  
+
   def test_format_enabled_asker_should_return_false_when_format_has_no_type_and_base_has_not_value
     assert_equal create_internal.format_enabled?, false
   end
-  
+
   def test_format_enabled_asker_should_return_false_constantly_when_tblock_is_multiple_mode
-    tblock = create_internal('multiple' => 'true', 
+    tblock = create_internal('multiple' => 'true',
                              'format'   => {'base' => '{value}',
                                             'type' => 'number'})
     tblock.format_enabled(true)
-    
+
     assert_equal tblock.format_enabled?, false
   end
-  
+
   def test_type_of_asker_should_return_true_when_value_is_tblock
     assert_equal create_internal.type_of?(:tblock), true
   end
-  
+
   def test_type_of_asker_should_return_true_when_value_is_block
     assert_equal create_internal.type_of?(:block), true
   end
-  
+
   def test_formatter_should_return_instance_of_FormatterBasic_when_format_is_enable
     tblock = create_internal('format' => {'type' => 'datetime'})
-    
+
     assert_kind_of TextBlock::Formatter::Basic, tblock.send(:formatter)
   end
-end
+end