thinreports 0.7.7 → 0.8.0

data/test/unit/layout/test_base.rb

@@ -1,92 +1,47 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Layout::TestBase < Minitest::Test
+  include Thinreports::TestHelper
+
+  Layout = Thinreports::Layout
 
-class ThinReports::Layout::TestBase < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  # Alias
-  Layout = ThinReports::Layout::Base
-  
-  def test_load_format_raise_error_when_file_not_found
-    assert_raises ThinReports::Errors::LayoutFileNotFound do
-      Layout.load_format('dummy.tlf')
-    end
-  end
-  
   def test_load_format
-    flexmock(File).should_receive(:exists? => true).once
-    flexmock(ThinReports::Layout::Format).should_receive(:build).once
-    
-    Layout.load_format('sample.tlf')
-  end
-  
-  def test_load_format_when_omit_the_file_extension
-    specified_name = 'sample'
-    resolved_name  = 'sample.tlf'
-    
-    flexmock(File).
-      should_receive(:exists?).with(resolved_name).and_return(true).once
-    flexmock(ThinReports::Layout::Format).should_receive(:build).once
-    
-    Layout.load_format(specified_name)
-  end
-  
-  def test_Page_when_not_defined_PageHelpers
-    assert_same Layout.Page, ThinReports::Core::Page
-  end
-  
-  def test_Page_when_defined_PageHelpers
-    Layout.send(:PageHelpers, &proc{})
-    
-    refute_same Layout.Page, ThinReports::Core::Page
-    
-    # Teardown
-    ThinReports::Layout::Base.send(:remove_const, :Page)
-  end
-  
-  def test_PageHelpers
-    Layout.send(:PageHelpers) do
-      def foo
-        'foo'
-      end
+    assert_instance_of Layout::Format,
+                       Layout::Base.load_format(data_file('layout_text1.tlf'))
+    assert_instance_of Layout::Format,
+                       Layout::Base.load_format(data_file('layout_text1'))
+
+    assert_raises Thinreports::Errors::LayoutFileNotFound do
+      Layout::Base.load_format 'unknown.tlf'
     end
-    
-    assert_same Layout::Page.superclass, ThinReports::Core::Page
-    assert Layout::Page.method_defined?(:foo)
-    
-    # Teardown
-    ThinReports::Layout::Base.send(:remove_const, :Page)
   end
-  
-  def test_initialize_with_specified_id
-    layout = init_layout(:id => :foo)
-    assert_equal layout.id, :foo
+
+  def test_new
+    layout = create_layout id: 'foo'
+
+    assert_equal 'foo', layout.id
+    assert_equal data_file('layout_text1.tlf'), layout.filename
   end
-  
+
   def test_default?
-    assert_equal init_layout.default?, true
-    assert_equal init_layout(:id => :foo).default?, false
+    assert_equal false, create_layout(id: 'foo').default?
+    assert_equal true, create_layout.default?
   end
-  
+
   def test_config
-    layout = init_layout
-    assert_instance_of ThinReports::Layout::Configuration, layout.config
+    assert_instance_of Thinreports::Layout::Configuration,
+                       create_layout.config
   end
-  
-  def test_init_new_page
-    parent = flexmock('parent')
-    layout = init_layout
-    
-    # Should call ThinReports::Core::Page#new with parent and layout.
-    flexmock(ThinReports::Core::Page).
-      should_receive(:new).with(parent, layout, {}).once
-    
-    layout.init_new_page(parent)
+
+  def test_new_page
+    report = new_report 'layout_text1'
+    assert_instance_of Thinreports::Report::Page,
+                       create_layout.new_page(report)
   end
-  
-  def init_layout(options = {})
-    flexmock(Layout).should_receive(:load_format => flexmock('format'))
-    Layout.new('dummy.tlf', options)
+
+  def create_layout(options = {})
+    Layout::Base.new data_file('layout_text1.tlf'), options
   end
-end
+end

data/test/unit/layout/test_configuration.rb

@@ -1,46 +1,21 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Layout::TestConfiguration < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Layout::TestConfiguration < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Configuration = ThinReports::Layout::Configuration
-  
+  Configuration = Thinreports::Layout::Configuration
+
   def setup
-    layout = flexmock('layout')
-    flexmock(layout).should_receive(:format => flexmock('layout_format'))
-    
+    layout = Thinreports::Layout.new data_file('layout_text1.tlf')
     @config = Configuration.new(layout)
   end
-  
-  def test_undef_items_method
-    refute_respond_to @config, :items
-  end
-  
-  def test_undef_values_method
-    refute_respond_to @config, :values
-  end
-  
-  def test_properly_set_init_item_handler
-    list_format = flexmock('list_format').should_receive(:type => 's-list').once.mock
-    list_config = flexmock('list_config').should_receive(:new).once.mock
-    
-    flexmock(ThinReports::Core::Shape).
-      should_receive(:Configuration).with('s-list').and_return(list_config).once
-      
-    @config.manager.init_item(list_format)
-  end
-  
-  def test_activate
-    list_config = flexmock('list_config').should_receive(:copy).once.mock
-    @config.manager.shapes[:foo] = list_config
 
-    @config.activate(:foo)
-  end
-  
-  def test_activate_return_nil_when_unknown_shape_id
-    assert_nil @config.activate(:unknown)
+  def test_disable_methods
+    assert_raises NoMethodError do
+      @config.values
+    end
   end
-end
+end

data/test/unit/layout/test_format.rb

@@ -1,10 +1,10 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Layout::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Layout::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   TEST_SIMPLE_FORMAT = <<-'EOF'
   {
     "version":"%s",
@@ -32,92 +32,89 @@ class ThinReports::Layout::TestFormat < MiniTest::Unit::TestCase
     }
   }
   EOF
-  
+
   # Alias
-  Shape  = ThinReports::Core::Shape
-  Layout = ThinReports::Layout
-  
+  Shape  = Thinreports::Core::Shape
+  Layout = Thinreports::Layout
+
   def test_report_title_should_return_the_value_of_config_title_key
     format = Layout::Format.new('config' => {'title' => 'Title'})
     assert_equal format.report_title, 'Title'
   end
-  
+
   def test_user_paper_type_asker_should_return_true_when_paper_type_is_user
     format = Layout::Format.new('config' => {'page' => {'paper-type' => 'user'}})
     assert_equal format.user_paper_type?, true
   end
-  
+
   def test_user_paper_type_asker_should_return_false_when_paper_type_is_not_user
     format = Layout::Format.new('config' => {'page' => {'paper-type' => 'A4'}})
     assert_equal format.user_paper_type?, false
   end
-  
+
   def test_last_version_should_return_the_value_of_version_key
     format = Layout::Format.new('version' => '1.0')
     assert_equal format.last_version, '1.0'
   end
-  
+
   def test_build_should_properly_build_layout_format
-    build_format(:force => true)
+    build_format(force: true)
   rescue => e
     flunk exception_details(e, 'Faile to build.')
   end
-  
+
   def test_build_should_properly_set_built_shapes_to_shapes_attributes_of_format
     assert_equal build_format.shapes.size, 4
   end
-  
+
   def test_config_attributes_of_built_format_should_not_have_unnecessary_attributes
-    format = build_format(:force => true)
+    format = build_format(force: true)
     config = format.instance_variable_get(:@config)
-    
+
     refute %w( version finger-print state).any? {|a| config.key?(a)},
            'A config attributes of built format have unnecessary attributes.'
   end
-  
+
   def test_identifier_should_return_the_digest_value_of_the_raw_layout_using_sha1
     format = build_format
     expect = Digest::SHA1.hexdigest(create_raw_format)
-    
+
     assert_equal format.identifier, expect.to_sym
   ensure
-    clear_building_cache
+    clear_cache_for_building
   end
-  
+
   def test_build_should_always_return_the_same_result_in_cache_mode
     result1 = build_format
     result2 = build_format
-    
+
     assert_same result1, result2
   ensure
-    clear_building_cache
+    clear_cache_for_building
   end
-  
+
   def test_build_should_raise_when_layout_file_is_incompatible
     original_rules = Layout::Version::REQUIRED_RULES.dup
     Layout::Version::REQUIRED_RULES.replace(['>= 0.6.0.pre3', '< 0.8.0'])
-    
-    assert_raises ThinReports::Errors::IncompatibleLayoutFormat do
-      build_format(:version => '0.6.0.pre2')
+
+    assert_raises Thinreports::Errors::IncompatibleLayoutFormat do
+      build_format(version: '0.6.0.pre2')
     end
   ensure
     Layout::Version::REQUIRED_RULES.replace(original_rules)
-    clear_building_cache
+    clear_cache_for_building
   end
-  
+
   def create_raw_format(version = nil)
-    clean_whitespaces(TEST_SIMPLE_FORMAT) % (version || ThinReports::VERSION)
+    clean_whitespaces(TEST_SIMPLE_FORMAT) % (version || Thinreports::VERSION)
   end
-  
+
   def build_format(options = {})
-    flexmock(Layout::Format).
-      should_receive(:read_format_file).
-      and_return(create_raw_format(options[:version]))
-    
-    Layout::Format.build('dummy.tlf', :force => options[:force])
+    Layout::Format.stubs(read_format_file: create_raw_format(options[:version]))
+    Layout::Format.build('dummy.tlf', force: options[:force])
   end
-  
-  def clear_building_cache
+
+  def clear_cache_for_building
     Layout::Format.send(:built_format_registry).clear
   end
-end
+end

data/test/unit/layout/test_version.rb

@@ -1,12 +1,12 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Layout::TestVersion < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Layout::TestVersion < Minitest::Test
+  include Thinreports::TestHelper
   
   # Alias
-  Version = ThinReports::Layout::Version
+  Version = Thinreports::Layout::Version
   
   def test_comparable_version_should_add_99_when_the_given_version_is_not_PRE
     assert_equal Version.comparable_version('0.7.0'), '0.7.0.99'

data/test/unit/report/test_base.rb

@@ -1,76 +1,91 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Report::TestBase < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Report::TestBase < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Report = ThinReports::Report
-  
+  Report = Thinreports::Report
+
   def setup
     @report = Report::Base.new
   end
-  
+
+  def test_on_page_create_callback
+    report = Report::Base.new layout: data_file('layout_text1.tlf')
+
+    counter = 0
+    callback = -> page {
+      assert_instance_of Report::Page, page
+      counter += 1
+    }
+
+    report.on_page_create(&callback)
+
+    2.times { report.start_new_page }
+    assert_equal counter, 2
+  end
+
   def test_initialize_should_register_layout_as_default_when_layout_is_specified_as_the_option
-    report = Report::Base.new :layout => data_file('basic_layout1.tlf')
-    assert_equal report.default_layout.filename, data_file('basic_layout1.tlf')
+    report = Report::Base.new layout: data_file('layout_text1.tlf')
+    assert_equal report.default_layout.filename, data_file('layout_text1.tlf')
   end
-  
+
   def test_initialize_should_initialize_new_Report_without_default_layout
     assert_nil @report.default_layout
   end
-  
+
   def test_use_layout_should_register_default_layout_when_default_property_is_omitted
-    @report.use_layout(data_file('basic_layout1.tlf'))
-    
-    assert_equal @report.default_layout.filename, data_file('basic_layout1.tlf')
+    @report.use_layout(data_file('layout_text1.tlf'))
+
+    assert_equal @report.default_layout.filename, data_file('layout_text1.tlf')
   end
-  
+
   def test_use_layout_should_register_default_layout_when_default_property_is_true
-    @report.use_layout(data_file('basic_layout2.tlf'), :default => true)
-    
-    assert_equal @report.default_layout.filename, data_file('basic_layout2.tlf')
+    @report.use_layout(data_file('layout_text2.tlf'), default: true)
+
+    assert_equal @report.default_layout.filename, data_file('layout_text2.tlf')
   end
-  
+
   def test_start_new_page_should_properly_create_a_new_Page_and_return
-    @report.use_layout(data_file('basic_layout1'))
-    
-    assert_instance_of ThinReports::Core::Page, @report.start_new_page
+    @report.use_layout(data_file('layout_text1'))
+
+    assert_instance_of Thinreports::Report::Page, @report.start_new_page
   end
-  
+
   def test_start_new_page_should_raise_when_the_layout_has_not_been_registered_yet
-    assert_raises ThinReports::Errors::NoRegisteredLayoutFound do
-      @report.start_new_page(:layout => :unknown)
+    assert_raises Thinreports::Errors::NoRegisteredLayoutFound do
+      @report.start_new_page(layout: :unknown)
     end
   end
-  
+
   def test_start_new_page_should_create_a_new_page_using_a_default_layout
-    @report.use_layout(data_file('basic_layout1.tlf'), :default => true)
-    
-    assert_equal @report.start_new_page.layout.filename, data_file('basic_layout1.tlf')
+    @report.use_layout(data_file('layout_text1.tlf'), default: true)
+
+    assert_equal @report.start_new_page.layout.filename, data_file('layout_text1.tlf')
   end
-  
+
   def test_start_new_page_should_create_a_new_page_using_a_layout_with_specified_id
-    @report.use_layout(data_file('basic_layout1.tlf'), :id => :foo)
-    
-    assert_equal @report.start_new_page(:layout => :foo).layout.filename,
-                 data_file('basic_layout1.tlf')
+    @report.use_layout(data_file('layout_text1.tlf'), id: :foo)
+
+    assert_equal @report.start_new_page(layout: :foo).layout.filename,
+                 data_file('layout_text1.tlf')
   end
-  
+
   def test_start_new_page_should_create_a_new_page_using_a_specified_layoutfile
-    new_page = @report.start_new_page(:layout => data_file('basic_layout1.tlf'))
-    assert_equal new_page.layout.filename, data_file('basic_layout1.tlf')
+    new_page = @report.start_new_page(layout: data_file('layout_text1.tlf'))
+    assert_equal new_page.layout.filename, data_file('layout_text1.tlf')
   end
 
   def test_start_new_page_with_count_option
-    @report.use_layout data_file('basic_layout1.tlf'), :default => true
+    @report.use_layout data_file('layout_text1.tlf'), default: true
 
-    new_page = @report.start_new_page :count => false
+    new_page = @report.start_new_page count: false
     assert_nil new_page.no
     assert_equal @report.page_count, 0
 
-    new_page = @report.start_new_page :count => true
+    new_page = @report.start_new_page count: true
     assert_equal new_page.no, 1
     assert_equal @report.page_count, 1
 
@@ -78,144 +93,104 @@ class ThinReports::Report::TestBase < MiniTest::Unit::TestCase
     assert_equal new_page.no, 2
     assert_equal @report.page_count, 2
   end
-  
+
   def test_add_blank_page_should_properly_create_a_new_blank_page
-    @report.use_layout(data_file('basic_layout1'))
-    
-    assert_instance_of ThinReports::Core::BlankPage, @report.add_blank_page
+    @report.use_layout(data_file('layout_text1'))
+
+    assert_instance_of Thinreports::Report::BlankPage, @report.add_blank_page
   end
-  
+
   def test_layout_should_return_the_default_layout_with_no_arguments
-    @report.use_layout(data_file('basic_layout1.tlf'), :default => true)
-    
-    assert_equal @report.layout.filename, data_file('basic_layout1.tlf')
+    @report.use_layout(data_file('layout_text1.tlf'), default: true)
+
+    assert_equal @report.layout.filename, data_file('layout_text1.tlf')
   end
-  
+
   def test_layout_should_raise_when_the_specified_layout_is_not_found
-    assert_raises ThinReports::Errors::UnknownLayoutId do
+    assert_raises Thinreports::Errors::UnknownLayoutId do
       @report.layout(:unknown_layout_id)
     end
   end
-  
+
   def test_layout_should_return_the_layout_with_specified_id
-    @report.use_layout(data_file('basic_layout2.tlf'), :id => :foo)
-    
-    assert_equal @report.layout(:foo).filename, data_file('basic_layout2.tlf')
-  end
-  
-  def test_generate_should_properly_initialize_Generator_and_call_generate_method_when_type_is_specified
-    flexmock(ThinReports::Generator).
-      should_receive(:new).
-      with(:pdf, @report, {:option => :value}).
-      and_return(flexmock(:generate => 'Success')).once
-    
-    assert_equal @report.generate(:pdf, :option => :value), 'Success'
-  end
-  
-  def test_generate_should_properly_initialize_Generator_and_call_generate_method_when_type_is_omitted
-    flexmock(ThinReports::Generator).
-      should_receive(:new).
-      with(:pdf, @report, {:option => :value}).
-      and_return(flexmock(:generate => 'Success')).once
-    
-    assert_equal @report.generate(:option => :value), 'Success'
+    @report.use_layout(data_file('layout_text2.tlf'), id: :foo)
+
+    assert_equal @report.layout(:foo).filename, data_file('layout_text2.tlf')
   end
 
-  def test_generate_should_call_generate_file_method_when_filename_option_is_given
-    flexmock(ThinReports::Generator).
-      should_receive(:new).
-      with(:pdf, @report, {}).
-      and_return(flexmock(:generate_file => 'Success')).once
+  def test_generate_with_filename
+    report = Report::Base.new layout: data_file('layout_text1.tlf')
 
-    assert_equal @report.generate(:filename => 'foo.pdf'), 'Success'
+    report.generate :pdf, filename: temp_path.join('result1.pdf')
+    report.generate filename: temp_path.join('result2.pdf')
+
+    assert File.exists?(temp_path.join('result1.pdf'))
+    assert File.exists?(temp_path.join('result2.pdf'))
+
+    assert_equal File.read(temp_path.join('result1.pdf')),
+                 File.read(temp_path.join('result2.pdf'))
   end
 
-  def test_generate_file_should_warn_the_DEPRECATION_WARNING
-    report = create_basic_report('basic_layout1')
+  def test_events_should_return_Report_Events
+    assert_instance_of Thinreports::Report::Events, @report.events
+  end
 
+  def test_events_should_deprecated
     out, err = capture_io do
-      report.generate_file(temp_file)
+      @report.events
     end
-    assert_match /DEPRECATION/, err
-  end
-  
-  def test_generate_file_should_properly_initialize_Generator_and_call_generate_file_method_when_type_is_specified
-    generator = flexmock('generator')
-    generator.should_receive(:generate_file).with('output.pdf').once
-    
-    flexmock(ThinReports::Generator).
-      should_receive(:new).
-      with(:pdf, @report, {}).
-      and_return(generator).once
-    
-    @report.generate_file(:pdf, 'output.pdf')
-  end
-  
-  def test_generate_file_should_properly_initialize_Generator_and_call_generate_file_method_when_type_is_omitted
-    generator = flexmock('generator')
-    generator.should_receive(:generate_file).with('output.pdf').once
-    
-    flexmock(ThinReports::Generator).
-      should_receive(:new).
-      with(:pdf, @report, {:option => :value}).
-      and_return(generator).once
-    
-    @report.generate_file('output.pdf', :option => :value)
-  end
-  
-  def test_events_should_return_Report_Events
-    assert_instance_of ThinReports::Report::Events, @report.events
+    assert_includes err, '[DEPRECATION]'
   end
-  
+
   def test_page_should_return_the_current_page
-    @report.use_layout(data_file('basic_layout1.tlf'))
+    @report.use_layout(data_file('layout_text1.tlf'))
     @report.start_new_page
-    
-    assert_instance_of ThinReports::Core::Page, @report.page
+
+    assert_instance_of Thinreports::Report::Page, @report.page
   end
-  
+
   def test_page_count_should_return_total_page_count
-    @report.use_layout(data_file('basic_layout1.tlf'))
+    @report.use_layout(data_file('layout_text1.tlf'))
     2.times { @report.start_new_page }
-    
+
     assert_equal @report.page_count, 2
   end
-  
+
   def test_finalize_should_finalize_report
     @report.finalize
     assert_equal @report.finalized?, true
   end
-  
+
   def test_finalized_asker_should_return_false_when_report_has_not_been_finalized_yet
     assert_equal @report.finalized?, false
   end
-  
+
   def test_finalized_asker_should_return_true_when_report_is_already_finalized
     @report.finalize
     assert_equal @report.finalized?, true
   end
-  
+
   def test_list_should_create_new_page_when_page_is_not_created
-    @report.use_layout(data_file('basic_list_layout.tlf'))
+    @report.use_layout(data_file('layout_list.tlf'))
     @report.list(:list)
-    
+
     refute_nil @report.page
   end
-  
+
   def test_list_should_create_new_page_when_page_is_finalized
     @report.tap do |r|
-      r.use_layout(data_file('basic_list_layout.tlf'))
+      r.use_layout(data_file('layout_list.tlf'))
       r.start_new_page
       r.page.finalize
     end
     @report.list(:list)
-    
+
     assert_equal @report.page.finalized?, false
   end
-  
+
   def test_list_should_properly_return_shape_with_the_specified_id
-    @report.use_layout(data_file('basic_list_layout.tlf'))
-    
+    @report.use_layout(data_file('layout_list.tlf'))
+
     assert_equal @report.list(:list).id, 'list'
   end
 
@@ -224,130 +199,76 @@ class ThinReports::Report::TestBase < MiniTest::Unit::TestCase
     @report.start_page_number_from 10
     assert_equal @report.start_page_number, 10
   end
-  
+
   def test_Base_create_should_finalize_report
     report = Report::Base.create do |r|
       assert_instance_of Report::Base, r
     end
     assert_equal report.finalized?, true
   end
-  
+
   def test_Base_create_should_raise_when_no_block_given
     assert_raises ArgumentError do
       Report::Base.create
     end
   end
-  
-  def test_Base_generate_should_properly_generate_when_type_is_specified
-    flexmock(Report::Base).new_instances.
-      should_receive(:generate).
-      with(:pdf, :option => :value).once
-    
-    flexmock(Report::Base).
-      should_receive(:create).
-      with({:layout => 'layout.tlf'}, Proc).
-      and_return(Report::Base.new).once
-    
-    Report::Base.generate(:pdf, :report    => {:layout => 'layout.tlf'},
-                                :generator => {:option => :value}) {}
-  end
-  
-  def test_Base_generate_should_properly_generate_when_type_is_omitted
-    flexmock(Report::Base).new_instances.
-      should_receive(:generate).
-      with({}).once
-    
-    flexmock(Report::Base).
-      should_receive(:create).
-      with({}, Proc).
-      and_return(Report::Base.new).once
-    
-    Report::Base.generate {}
-  end
-  
-  def test_Base_generate_file_should_properly_generate_file_when_type_is_specified
-    flexmock(Report::Base).new_instances.
-      should_receive(:generate_file).
-      with(:pdf, 'output.pdf', {}).once
-    
-    flexmock(Report::Base).
-      should_receive(:create).
-      with({:layout => 'layout.tlf'}, Proc).
-      and_return(Report::Base.new).once
-    
-    Report::Base.generate_file(:pdf, 'output.pdf', :report => {:layout => 'layout.tlf'}) {}
-  end
-
-  def test_Base_generate_file_should_warn_the_DEPRICATION_WARNING
-    out, err = capture_io do
-      Report.generate_file(temp_file, :report => {:layout => data_file('basic_layout1')}) { start_new_page }
-    end
-    assert_match /DEPRECATION/, err
-  end
-  
-  def test_Base_generate_file_should_properly_generate_file_when_type_is_omitted
-    flexmock(Report::Base).new_instances.
-      should_receive(:generate_file).
-      with('output.pdf', :option => :value).once
-      
-    flexmock(Report::Base).
-      should_receive(:create).
-      with({}, Proc).
-      and_return(Report::Base.new).once
-    
-    Report::Base.generate_file('output.pdf', :generator => {:option => :value}) {}
-  end
-  
+
+  def test_Base_generate_with_filename
+    layout_file = data_file 'layout_text1.tlf'
+
+    Report::Base.generate(:pdf, report: { layout: layout_file },
+                          generator: { filename: temp_path.join('result1.pdf') }) {}
+    Report::Base.generate(report: { layout: layout_file },
+                          generator: { filename: temp_path.join('result2.pdf') }) {}
+
+    assert_equal temp_path.join('result1.pdf').read,
+                 temp_path.join('result2.pdf').read
+  end
+
   def test_Base_generate_should_raise_when_no_block_given
     assert_raises ArgumentError do
       Report::Base.generate(:pdf)
     end
   end
-  
-  def test_Base_generate_file_should_raise_when_no_block_given
-    assert_raises ArgumentError do
-      Report::Base.generate_file(:pdf, 'output.pdf')
-    end
-  end
-  
+
   def test_Base_extract_options_should_return_as_report_option_the_value_which_has_report_in_a_key
-    report, generator = Report::Base.send(:extract_options!, [{:report => {:layout => 'hoge.tlf'}}])
+    report, generator = Report::Base.send(:extract_options!, [{report: {layout: 'hoge.tlf'}}])
     assert_equal report[:layout], 'hoge.tlf'
   end
-  
+
   def test_Base_extract_options_should_operate_an_argument_destructively
-    args = [:pdf, 'output.pdf', {:report => {:layout => 'foo.tlf'}}]
+    args = [:pdf, 'output.pdf', {report: {layout: 'foo.tlf'}}]
     Report::Base.send(:extract_options!, args)
     assert_equal args, [:pdf, 'output.pdf']
   end
-  
+
   def test_Base_extract_options_should_include_the_layout_key_in_the_report_option
-    report, generator = Report::Base.send(:extract_options!, [{:layout => 'hoge.tlf'}])
+    report, generator = Report::Base.send(:extract_options!, [{layout: 'hoge.tlf'}])
     assert_equal report[:layout], 'hoge.tlf'
   end
-  
+
   def test_Base_extract_options_should_give_priority_to_the_value_of_the_layout_key_over_in_the_report_option
     report, generator = Report::Base.send(:extract_options!,
-                                          [{:report => {:layout => 'foo.tlf'}, :layout => 'hoge.tlf'}])
+                                          [{report: {layout: 'foo.tlf'}, layout: 'hoge.tlf'}])
     assert_equal report[:layout], 'hoge.tlf'
   end
-  
+
   def test_Base_extract_options_should_return_as_generator_option_the_value_which_has_generator_in_a_key
     report, generator = Report::Base.send(:extract_options!,
-                                          [{:generator => {:option => 'value'}}])
+                                          [{generator: {option: 'value'}}])
     assert_equal generator[:option], 'value'
   end
-  
+
   def test_Base_extract_options_should_give_priority_to_the_value_of_other_keys_over_in_the_generator_option
     report, generator = Report::Base.send(:extract_options!,
-                                          [{:generator => {:option => 'value1'}, :option => 'value2'}])
+                                          [{generator: {option: 'value1'}, option: 'value2'}])
     assert_equal generator[:option], 'value2'
   end
-  
+
   def test_Base_extract_options_should_return_all_the_values_except_the_report_option_as_a_generator_option
     report, generator = Report::Base.send(:extract_options!,
-                                          [{:report => {:layout => 'foo.tlf'}, :layout => 'hoge.tlf',
-                                            :generator_opt1 => 'value1', :generator_opt2 => 'value2'}])
+                                          [{report: {layout: 'foo.tlf'}, layout: 'hoge.tlf',
+                                            generator_opt1: 'value1', generator_opt2: 'value2'}])
     assert_equal generator.values_at(:generator_opt1, :generator_opt2),
                  ['value1', 'value2']
   end