thinreports 0.7.7 → 0.8.0

data/test/unit/core/format/test_builder.rb

@@ -1,14 +1,14 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Format::TestBuilder < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   TEST_RAW_FORMAT = <<-'EOS'
     {
-      "node1":"\u3042\u6f22\u5b57\uff20\u3231\u2160\u30ab\u30ca\uff76\uff85",
-      "node2":{"node2_child":"node2_child value"},
+      "node1": "あ漢字＠㈱Ⅰカナｶﾅ",
+      "node2": { "node2_child":"node2_child value" },
       "layout":
         "<svg width=\"595.2\" height=\"841.8\">
            <g class=\"canvas\">
@@ -19,22 +19,17 @@ class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
          </svg>"
     }
   EOS
-  
-  class TestFormat < ThinReports::Core::Format::Base
-    extend ::ThinReports::Core::Format::Builder
-  
+
+  class TestFormat < Thinreports::Core::Format::Base
+    extend ::Thinreports::Core::Format::Builder
     config_reader :layout
     config_accessor :shapes
-    
-    # For test
-    public_class_method :parse_json, :build_layout, :clean,
-                        :clean_with_attributes, :shape_tag
   end
-  
+
   def setup
     @raw_format = clean_whitespaces(TEST_RAW_FORMAT)
   end
-  
+
   def test_parse_json
     expected_format = {
       "node1" => "あ漢字＠㈱Ⅰカナｶﾅ",
@@ -53,15 +48,15 @@ class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
     }
     assert_equal TestFormat.parse_json(@raw_format), expected_format
   end
-  
+
   def test_build_layout
     format = TestFormat.new(TestFormat.parse_json(@raw_format))
     format.shapes = {}
 
     TestFormat.build_layout(format) do |type, f|
-      flexmock(:id => f['id'])
+      Thinreports::Core::Shape::Format(type).build(f)
     end
-    
+
     assert_equal format.layout, clean_whitespaces(<<-'EOS')
       <svg width="595.2" height="841.8">
         <g class="canvas">
@@ -72,7 +67,7 @@ class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
     EOS
     assert_includes format.shapes.keys, :t1
   end
-  
+
   def test_clean
     source = clean_whitespaces(<<-'EOS')
       <svg width="595.2" height="841.8">
@@ -89,7 +84,7 @@ class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
       </svg>
     EOS
   end
-  
+
   def test_clean_with_attributes
     source = clean_whitespaces(<<-'EOS')
       <svg width="595.2" height="841.8">
@@ -106,8 +101,9 @@ class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
       </svg>
     EOS
   end
-  
+
   def test_shape_tag
-    assert_equal TestFormat.shape_tag(flexmock(:id => :foo)), '<%= r(:"foo")%>'
+    shape_format = stub(id: :foo)
+    assert_equal TestFormat.shape_tag(shape_format), '<%= r(:"foo")%>'
   end
 end

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

@@ -1,89 +1,86 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Base::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
+
+  def setup
+    @report = Thinreports::Report.new layout: data_file('layout_text1.tlf')
+    @report.start_new_page
+  end
 
-class ThinReports::Core::Shape::Base::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   def create_internal(format_config = {}, &block)
     format = unless format_config.empty?
-      format_klass = ::Class.new(ThinReports::Core::Shape::Basic::Format) {
+      format_klass = Class.new(Thinreports::Core::Shape::Basic::Format) {
         config_reader(*format_config.keys.map {|k| k.to_sym })
       }
       format_klass.new(format_config)
     else
-      ThinReports::Core::Shape::Basic::Format.new({})
+      Thinreports::Core::Shape::Basic::Format.new({})
     end
-    
-    klass = ::Class.new(ThinReports::Core::Shape::Base::Internal, &block)
-    klass.new(flexmock('parent'), format)
+
+    klass = Class.new(Thinreports::Core::Shape::Base::Internal, &block)
+    klass.new(@report.page, format)
   end
-  
+
   def test_self_format_delegators_should_defines_method_delegated_from_format
     internal = create_internal('m1' => 'm1_value') {
       format_delegators :m1
     }
     assert_respond_to internal, :m1
   end
-  
+
   def test_method_delegated_from_format_should_return_same_value_as_an_format
     internal = create_internal('m1' => 'm1 value') {
       format_delegators :m1
     }
     assert_same internal.m1, internal.format.m1
   end
-  
-  def test_switch_parent_should_replace_a_parent_property_to_the_specified_new_parent
-    new_parent = flexmock('new_parent')
-    
-    internal = create_internal
-    internal.switch_parent!(new_parent)
-    
-    assert_same internal.parent, new_parent
-  end
-  
+
   def test_copied_internal_should_have_the_new_value_specified_as_a_parent_property
-    new_parent = flexmock('new_parent')
+    new_page = @report.start_new_page
     internal = create_internal {
       def style
-        @style ||= ThinReports::Core::Shape::Style::Base.new(format)
+        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
       end
     }
-    assert_same internal.copy(new_parent).parent, new_parent
+
+    assert_same internal.copy(new_page).parent, new_page
   end
-  
+
   def test_copied_internal_should_have_style_copied_from_original
     internal = create_internal {
       def style
-        @style ||= ThinReports::Core::Shape::Style::Base.new(format)
+        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
       end
     }
     internal.style.write_internal_style(:foo, 'bar')
-    new_internal = internal.copy(flexmock('new_parent'))
-    
+    new_internal = internal.copy(@report.start_new_page)
+
     assert_equal new_internal.style.read_internal_style(:foo), 'bar'
   end
-  
+
   def test_copied_internal_should_have_states_property_copied_from_original
     internal = create_internal {
       def style
-        @style ||= ThinReports::Core::Shape::Style::Base.new(format)
+        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
       end
     }
     internal.states[:foo] = 'bar'
-    new_internal = internal.copy(flexmock('new_parent'))
-    
+    new_internal = internal.copy(@report.start_new_page)
+
     assert_equal new_internal.states[:foo], 'bar'
   end
-  
+
   def test_copy_should_execute_block_with_new_internal_as_argument
     internal = create_internal {
       def style
-        @style ||= ThinReports::Core::Shape::Style::Base.new(format)
+        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
       end
     }
-    internal.copy(flexmock('new_parent')) do |new_internal|
-      assert_equal new_internal.is_a?(ThinReports::Core::Shape::Base::Internal), true
+    internal.copy(@report.start_new_page) do |new_internal|
+      assert_equal new_internal.is_a?(Thinreports::Core::Shape::Base::Internal), true
     end
   end
-end
+end

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

@@ -1,9 +1,9 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Basic::TestBlockFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Basic::TestBlockFormat < Minitest::Test
+  include Thinreports::TestHelper
   
   TEST_BLOCK_FORMAT = {
     "value" => "default value",
@@ -25,6 +25,6 @@ class ThinReports::Core::Shape::Basic::TestBlockFormat < MiniTest::Unit::TestCas
   end
   
   def format
-    ThinReports::Core::Shape::Basic::BlockFormat.new(TEST_BLOCK_FORMAT)
+    Thinreports::Core::Shape::Basic::BlockFormat.new(TEST_BLOCK_FORMAT)
   end
 end

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

@@ -1,27 +1,29 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Basic::TestBlockInterface < Minitest::Test
+  include Thinreports::TestHelper
+
+  Basic = Thinreports::Core::Shape::Basic
 
-class ThinReports::Core::Shape::Basic::TestBlockInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  Basic = ThinReports::Core::Shape::Basic
-  
   def setup
-    parent = flexmock('parent')
+    report = Thinreports::Report.new layout: data_file('layout_text1')
+    parent = report.start_new_page
+
     format = Basic::BlockFormat.new({})
-    internal = Basic::BlockInternal.new(parent, Basic::BlockFormat.new({}))
-    
-    @interface = Basic::BlockInterface.new(parent, format, internal)
+    internal = Basic::BlockInternal.new parent, format
+
+    @interface = Basic::BlockInterface.new parent, format, internal
   end
-  
+
   def test_value_should_work_as_reader_with_no_arguments
     @interface.internal.write_value('new value')
     assert_equal @interface.value, 'new value'
   end
-  
+
   def test_value_should_work_as_writer_with_arguments
     @interface.value('new value')
     assert_equal @interface.internal.read_value, 'new value'
   end
-end
+end

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

@@ -1,55 +1,58 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Basic::TestBlockInternal < Minitest::Test
+  include Thinreports::TestHelper
+
+  Basic = Thinreports::Core::Shape::Basic
 
-class ThinReports::Core::Shape::Basic::TestBlockInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  Basic = ThinReports::Core::Shape::Basic
-  
   def test_box_should_return_value_of_format
     internal = init_internal('box' => 'box of format')
     assert_equal internal.box, 'box of format'
   end
-  
+
   def test_read_value_should_return_value_from_format
     internal = init_internal('value' => 'default value')
     assert_equal internal.read_value, 'default value'
   end
-  
+
   def test_read_value_should_return_value_from_state_with_value_key
     internal = init_internal
     internal.states[:value] = 'new value'
     assert_equal internal.read_value, 'new value'
   end
-  
+
   def test_real_value_should_return_the_same_value_as_a_read_value_method
     internal = init_internal
     internal.states[:value] = 'foo'
     assert_same internal.real_value, internal.read_value
   end
-  
+
   def test_write_value_should_save_value_to_states_store_as_value
     internal = init_internal
     internal.write_value('new value')
     assert_equal internal.states[:value], 'new value'
   end
-  
+
   def test_type_of_asker_should_return_true_when_given_the_block_value
     assert_equal init_internal.type_of?(:block), true
   end
-  
+
   def test_value_should_works_the_same_as_read_value_method
     internal = init_internal
     internal.write_value('new value')
     assert_same internal.read_value, internal.value
   end
-  
+
   def test_type_of_asker_should_return_false_otherwise
     assert_equal [:iblock, :tblock, :text, :list].all? {|t| !init_internal.type_of?(t)}, true
   end
-  
+
   def init_internal(format = {})
-    Basic::BlockInternal.new(flexmock('parent'), Basic::BlockFormat.new(format))
+    report = Thinreports::Report.new layout: data_file('layout_text1')
+    parent = report.start_new_page
+
+    Basic::BlockInternal.new(parent, Basic::BlockFormat.new(format))
   end
-end
+end

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

@@ -1,9 +1,9 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Basic::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Basic::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
 
   TEST_BASIC_FORMAT = {
     "type" => "s-rect",
@@ -28,7 +28,7 @@ class ThinReports::Core::Shape::Basic::TestFormat < MiniTest::Unit::TestCase
   }
 
   # Alias
-  Format = ThinReports::Core::Shape::Basic::Format
+  Format = Thinreports::Core::Shape::Basic::Format
 
   def test_build_basic_format
     build_basic_format

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

@@ -1,118 +1,108 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Basic::TestInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Basic::TestInterface < Minitest::Test
+  include Thinreports::TestHelper
 
   # Alias
-  Basic = ThinReports::Core::Shape::Basic
-  
+  Basic = Thinreports::Core::Shape::Basic
+
   def create_interface(format_config = {})
-    Basic::Interface.new(flexmock('parent'),
-                         Basic::Format.new(format_config))
-  end
-  
-  def setup
-    format = flexmock('format')
-    format.should_receive(:display? => true)
-    
-    @basic = Basic::Interface.new(flexmock('parent'), format)
+    report = Thinreports::Report.new layout: data_file('layout_text1')
+    parent = report.start_new_page
+
+    Basic::Interface.new parent, Basic::Format.new(format_config)
   end
-  
+
   def test_id_should_return_id_with_reference_to_internal
     basic = create_interface('id' => 'foo')
     assert_equal basic.id, basic.internal.id
   end
-  
+
   def test_id_should_return_cloned_id
     basic = create_interface('id' => 'basic-id')
     refute_same basic.id, basic.internal.id
   end
-  
+
   def test_type_should_operate_as_delegator_of_internal
     basic = create_interface('type' => 's-rect')
     assert_same basic.type, basic.internal.type
   end
-  
+
   def test_visible_asker_should_return_result_with_reference_to_style_of_internal
     basic = create_interface('display' => 'false')
     assert_equal basic.visible?, basic.internal.style.visible
   end
-  
+
   def test_visible_should_properly_set_visibility_to_style_of_internal
     basic = create_interface('display' => 'false')
     basic.visible(true)
-    
+
     assert_equal basic.internal.style.visible, true
   end
-  
+
   def test_style_should_operate_as_reader_when_one_argument_is_given
     basic = create_interface('svg' => {'attrs' => {'fill' => '#ff0000'}})
-    
+
     assert_equal basic.style(:fill_color), '#ff0000'
   end
-  
+
   def test_style_should_operate_as_writer_when_two_arguments_are_given
     basic = create_interface
     basic.style(:border_color, '#000000')
-    
+
     assert_equal basic.style(:border_color), '#000000'
   end
-  
+
   def test_style_should_operate_as_writer_for_border_style_when_three_arguments_are_given
     basic = create_interface
     basic.style(:border, 1, '#ffffff')
-    
+
     assert_equal basic.style(:border), [1, '#ffffff']
   end
-  
+
   def test_style_should_return_self_when_two_arguments_are_given
     assert_instance_of Basic::Interface, create_interface.style(:border_width, 1)
   end
-  
+
   def test_style_should_return_self_when_three_arguments_are_given
     assert_instance_of Basic::Interface, create_interface.style(:border, 1, '#000000')
   end
-  
+
   def test_styles_should_properly_set_the_specified_styles_as_Hash
     basic = create_interface
-    basic.styles(:fill_color   => '#ff0000',
-                 :border_color => '#000000',
-                 :border_width => 5,
-                 :visible      => false)
-    
+    basic.styles(fill_color: '#ff0000',
+                 border_color: '#000000',
+                 border_width: 5,
+                 visible: false)
+
     assert_equal [basic.style(:fill_color),
                   basic.style(:border_color),
                   basic.style(:border_width),
                   basic.style(:visible)],
                  ['#ff0000', '#000000', 5, false]
   end
-  
-  def test_styles_should_return_self
-    basic = create_interface
-    assert_instance_of Basic::Interface, basic.styles(:fill => '#ff0000')
-  end
-  
+
   def test_hide_should_properly_set_false_to_visibility
     basic = create_interface
     basic.hide
-    
+
     assert_equal basic.visible?, false
   end
-  
+
   def test_hide_should_return_self
     assert_instance_of Basic::Interface, create_interface.hide
   end
-  
+
   def test_show_should_properly_set_true_to_visibility
     basic = create_interface
     basic.show
-    
+
     assert_equal basic.visible?, true
   end
-  
+
   def test_show_should_return_self
     assert_instance_of Basic::Interface, create_interface.show
   end
-end
+end