thinreports 0.6.0.pre3 → 0.7.0

data/test/unit/generator/pdf/document/test_parse_color.rb

@@ -2,11 +2,11 @@
 
 require 'test/unit/helper'
 
-class ThinReports::Generator::Pdf::TestParseColor < MiniTest::Unit::TestCase
+class ThinReports::Generator::PDF::TestParseColor < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
   class TestColorParser
-    include ThinReports::Generator::Pdf::ParseColor
+    include ThinReports::Generator::PDF::ParseColor
   end
   
   def setup

data/test/unit/generator/pdf/test_configuration.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::PDF::TestConfiguration < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  def setup
+    @config = ThinReports::Generator::PDF::Configuration.new
+  end
+  
+  def test_eudc_fonts_can_only_set_font_of_TTF
+    assert_raises ArgumentError do
+      @config.eudc_fonts = '/path/to/eudc'
+    end
+    assert_raises ArgumentError do
+      @config.eudc_fonts = %w( /path/to/eudc1.ttf /path/to/eudc2 )
+    end
+  end
+  
+  def test_eudc_fonts_should_return_empty_array_by_default
+    assert_equal @config.eudc_fonts, []
+  end
+end

data/test/unit/generator/pdf/test_document.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::PDF::TestDocument < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Document = ThinReports::Generator::PDF::Document
+  
+  def test_new_without_page_creation
+    pdf = Document.new
+    assert_equal pdf.internal.page_count, 0
+  end
+  
+  def test_new_with_zero_margin_canvas
+    pdf = Document.new
+    assert_equal pdf.internal.page.margins.values, [0, 0, 0, 0]
+  end
+  
+  def test_new_with_security_settings
+    flexmock(Prawn::Document).new_instances.
+      should_receive(:encrypt_document).once.
+      with(:user_password => 'foo')
+    
+    Document.new(:security => {:user_password => 'foo'})
+  end
+end

data/test/unit/generator/test_configuration.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::TestConfiguration < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  def setup
+    @config = ThinReports::Generator::Configuration.new
+  end
+  
+  def test_pdf_should_return_configuration_of_pdf
+    assert_instance_of ThinReports::Generator::PDF::Configuration, @config.pdf
+  end
+  
+  def test_default_should_return_pdf_by_default
+    assert_equal @config.default, :pdf
+  end
+  
+  def test_default_should_raise_when_value_is_unknown_generator_type
+    assert_raises ThinReports::Errors::UnknownGeneratorType do
+      @config.default = :unknown
+    end
+  end
+end

data/test/unit/generator/test_pdf.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::TestPDF < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  PDF = ThinReports::Generator::PDF
+  
+  def test_new_should_set_title_as_metadata
+    report = create_basic_report('basic_layout1.tlf') {|r| r.start_new_page }
+    
+    flexmock(PDF::Document).should_receive(:new).
+      with(Hash, :Title => 'Basic Layout').once
+    
+    PDF.new(report, {})
+  end
+end

data/test/unit/helper.rb

@@ -34,4 +34,22 @@ module ThinReports::TestHelpers
       skip('This test is not required Ruby 1.8 below.')
     end
   end
+  
+  def create_basic_report(file, &block)
+    report = ThinReports::Report.new :layout => data_file(file)
+    block.call(report) if block_given?
+    report
+  end
+  
+  def create_basic_layout(file)
+    ThinReports::Layout.new(data_file(file))
+  end
+  
+  def create_basic_layout_format(file)
+    ThinReports::Layout::Format.build(data_file(file))
+  end
+  
+  def data_file(filename)
+    File.join(File.dirname(__FILE__), 'data', filename)
+  end
 end

data/test/unit/layout/test_format.rb

@@ -7,10 +7,7 @@ class ThinReports::Layout::TestFormat < MiniTest::Unit::TestCase
   
   TEST_SIMPLE_FORMAT = <<-'EOF'
   {
-    "built-at":"",
     "version":"%s",
-    "encoding":"utf-8",
-    "updated-at":"20110528120710",
     "finger-print":-860627816,
     "config":{
       "title":"Sample Layout",
@@ -37,6 +34,26 @@ class ThinReports::Layout::TestFormat < MiniTest::Unit::TestCase
   Shape  = ThinReports::Core::Shape
   Layout = ThinReports::Layout
   
+  def test_report_title
+    format = Layout::Format.new('config' => {'title' => 'Title'})
+    assert_equal format.report_title, 'Title'
+  end
+  
+  def test_user_paper_type_return_true_when_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_return_false_when_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
+    format = Layout::Format.new('version' => '1.0')
+    assert_equal format.last_version, '1.0'
+  end
+  
   def test_build_simple_format
     flexmock(Layout::Format).
       should_receive(:read_format_file).and_return(create_raw_format).once
@@ -77,12 +94,12 @@ class ThinReports::Layout::TestFormat < MiniTest::Unit::TestCase
     assert_same result1, result2
   end
   
-  def test_build_raise_when_layout_file_is_incompatible
+  def test_build_should_raise_when_layout_file_is_incompatible
     original_rules = Layout::Version::REQUIRED_RULES.dup
-    Layout::Version::REQUIRED_RULES.replace(['== 2.0.0'])
+    Layout::Version::REQUIRED_RULES.replace(['>= 0.6.0.pre3', '< 0.8.0'])
     
     flexmock(Layout::Format).
-      should_receive(:read_format_file).and_return(create_raw_format('1.0.0'))
+      should_receive(:read_format_file).and_return(create_raw_format('0.6.0.pre2'))
     
     assert_raises ThinReports::Errors::IncompatibleLayoutFormat do
       Layout::Format.build('dummy.tlf')
@@ -92,7 +109,7 @@ class ThinReports::Layout::TestFormat < MiniTest::Unit::TestCase
   end
   
   def setup
-    flexmock(Shape::Tblock::Format).
+    flexmock(Shape::TextBlock::Format).
       should_receive(:build).and_return {|f| flexmock(:id => f['id']) }
     flexmock(Shape::Basic::Format).
       should_receive(:build).and_return {|f| flexmock(:id => f['id']) }

data/test/unit/layout/test_version.rb

@@ -8,45 +8,79 @@ class ThinReports::Layout::TestVersion < MiniTest::Unit::TestCase
   # Alias
   Version = ThinReports::Layout::Version
   
-  def test_comparable_version
-    assert_equal Version.comparable_version('0.6.0'), '0.6.0.99'
+  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'
+  end
+  
+  def test_comparable_version_should_map_pre_to_1_when_the_given_version_is_PRE
     assert_equal Version.comparable_version('0.6.0.pre'), '0.6.0.1'
+  end
+  
+  def test_comparable_version_should_map_pre2_to_2_when_the_given_version_is_PRE2
     assert_equal Version.comparable_version('0.6.0.pre2'), '0.6.0.2'
   end
   
-  def test_compare_with_simple_rule
-    assert Version.compare('0.6.0', '== 0.6.0')
-    refute Version.compare('0.6.0', '== 0.6.1')
-    
-    refute Version.compare('0.6.0', '> 0.6.0')
-    assert Version.compare('0.6.1', '> 0.6.0')
-    assert Version.compare('0.6.0', '> 0.5.9')
-    assert Version.compare('0.6.0', '> 0.6.0.pre3')
-    assert Version.compare('0.6.0.pre2', '> 0.6.0.pre')
-    
-    assert Version.compare('0.6.0.pre', '< 0.6.0.pre3')
-    
-    assert Version.compare('0.6.0', '>= 0.6.0')
-    assert Version.compare('0.6.0', '<= 0.6.0')
+  def test_compare_with_equal_rule_should_return_true_when_the_given_version_is_equal_to_the_version_of_rule
+    assert Version.compare('0.7.0', '== 0.7.0')
+  end
+  
+  def test_compare_with_equal_rule_should_return_false_when_the_given_version_is_not_equal_to_the_version_of_rule
+    refute Version.compare('0.6.0.pre3', '== 0.6.0.pre2')
+  end
+  
+  def test_compare_with_larger_rule_should_return_true_when_the_given_version_is_larger_than_the_version_of_rule
+    assert Version.compare('0.7.0', '> 0.6.0.pre3')
+  end
+  
+  def test_compare_with_larger_rule_should_return_false_when_the_given_version_is_not_larger_than_the_version_of_rule
+    refute Version.compare('0.7.0', '> 0.7.0')
+  end
+  
+  def test_compare_with_one_or_more_rule_should_return_true_when_the_given_version_is_equal_to_the_version_of_rule
+    assert Version.compare('0.7.0', '>= 0.7.0')
+  end
+  
+  def test_compare_with_one_or_more_rule_should_return_true_when_the_given_version_is_larger_than_the_version_of_rule
+    assert Version.compare('0.7.0', '>= 0.6.0.pre3')
+  end
+  
+  def test_compare_with_one_or_more_rule_should_return_false_when_the_give_version_is_not_more_than_the_version_of_rule
+    refute Version.compare('0.6.0.pre3', '>= 0.7.0')
+  end
+  
+  def test_compare_with_one_or_less_rule_should_return_true_when_the_given_version_is_equal_to_the_version_of_rule
+    assert Version.compare('0.7.0', '<= 0.7.0')
   end
   
-  def test_compare_with_multiple_rules
-    assert Version.compare('0.6.0', '> 0.5.0', '< 1.0.0')
-    refute Version.compare('0.6.5', '> 0.6.0', '< 0.6.4')
+  def test_compare_with_one_or_less_rule_should_return_true_when_the_given_version_is_smaller_than_the_version_of_rule
+    assert Version.compare('0.7.0', '<= 0.7.1')
   end
   
-  def test_compatible?
-    required_rules('== 0.6.0.pre3') do
-      assert Version.compatible?('0.6.0.pre3')
+  def test_compare_with_one_or_less_rule_should_return_false_when_the_given_version_is_not_less_than_the_version_of_rule
+    refute Version.compare('0.7.0', '<= 0.6.0.pre3')
+  end
+  
+  def test_inspect_required_rules_should_properly_return_an_inspection_of_rule_when_one_rule_is_given
+    required_rules('== 0.6.0') do
+      assert_equal Version.inspect_required_rules, '(== 0.6.0)'
     end
   end
   
-  def test_required_rules_inspect
-    required_rules('== 0.6.0.pre3') do
-      assert_equal Version.required_rules_inspect, '(== 0.6.0.pre3)'
+  def test_inspect_required_rules_should_properly_return_an_inspection_of_rules_when_multiple_rules_are_given
+    required_rules('>= 0.6.0.pre3', '< 0.8.0') do
+      assert_equal Version.inspect_required_rules, '(>= 0.6.0.pre3 and < 0.8.0)'
     end
-    required_rules('> 0.6.0', '< 0.7.0') do
-      assert_equal Version.required_rules_inspect, '(> 0.6.0 and < 0.7.0)'
+  end
+  
+  def test_compatible_asker_should_return_true_when_the_given_version_matches_REEQUIRED_RULES
+    required_rules('>= 0.6.0.pre3', '< 0.8.0') do
+      assert Version.compatible?('0.7.0')
+    end
+  end
+  
+  def test_compatible_asker_should_return_false_when_the_given_version_does_not_matches_REQUIRED_RULES
+    required_rules('>= 0.6.0.pre3', '< 0.8.0') do
+      refute Version.compatible?('0.8.0')
     end
   end
   

data/test/unit/report/test_base.rb

@@ -12,176 +12,272 @@ class ThinReports::Report::TestBase < MiniTest::Unit::TestCase
     @report = Report::Base.new
   end
   
-  def test_initialize_with_options
-    flexmock(Report::Internal).
-      should_receive(:new).with(Report::Base, {:layout => 'layout.tlf'}).
-      and_return(flexmock('report_internal')).once
-    
-    report = Report::Base.new(:layout => 'layout.tlf')
-    assert_equal report.internal.flexmock_name, 'report_internal'
+  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')
+  end
+  
+  def test_initialize_should_initialize_new_Report_without_default_layout
+    assert_nil @report.default_layout
   end
   
-  def test_use_layout
-    flexmock(@report.internal).
-      should_receive(:register_layout).with('layout.tlf', {:default => true}).
-      and_return(flexmock('layout_config')).once
+  def test_use_layout_should_register_default_layout_when_default_property_is_omitted
+    @report.use_layout(data_file('basic_layout1.tlf'))
     
-    assert_equal @report.use_layout('layout.tlf', :default => true).flexmock_name,
-                 'layout_config'
+    assert_equal @report.default_layout.filename, data_file('basic_layout1.tlf')
   end
   
-  def test_start_new_page
-    layout = flexmock('layout')
-    layout.should_receive(:init_new_page).once
+  def test_use_layout_should_register_default_layout_when_default_property_is_true
+    @report.use_layout(data_file('basic_layout2.tlf'), :default => true)
     
-    flexmock(@report.internal).
-      should_receive(:load_layout).and_return(layout).once.
-      should_receive(:add_page).and_return(flexmock('new_page')).once
+    assert_equal @report.default_layout.filename, data_file('basic_layout2.tlf')
+  end
+  
+  def test_start_new_page_should_properly_create_a_new_Page_and_return
+    @report.use_layout(data_file('basic_layout1'))
     
-    assert_equal @report.start_new_page.flexmock_name, 'new_page'
+    assert_instance_of ThinReports::Core::Page, @report.start_new_page
   end
   
-  def test_start_new_page_raise_when_no_layout_registered_yet
+  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)
     end
   end
   
-  def test_add_blank_page
-    blank_page = flexmock('blank_page')
+  def test_start_new_page_should_create_a_new_page_using_a_default_layout
+    @report.use_layout(data_file('basic_layout1.tlf'), :default => true)
     
-    flexmock(ThinReports::Core::BlankPage).
-      should_receive(:new).and_return(blank_page)
+    assert_equal @report.start_new_page.layout.filename, data_file('basic_layout1.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)
     
-    flexmock(@report.internal).
-      should_receive(:add_page).with(blank_page)
+    assert_equal @report.start_new_page(:layout => :foo).layout.filename,
+                 data_file('basic_layout1.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')
+  end
+  
+  def test_add_blank_page_should_properly_create_a_new_blank_page
+    @report.use_layout(data_file('basic_layout1'))
     
-    @report.add_blank_page
+    assert_instance_of ThinReports::Core::BlankPage, @report.add_blank_page
   end
   
-  def test_layout_with_nil_return_the_default_layout
-    flexmock(@report.internal).
-      should_receive(:default_layout).and_return(flexmock('default_layout'))
+  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.flexmock_name, 'default_layout'
+    assert_equal @report.layout.filename, data_file('basic_layout1.tlf')
   end
   
-  def test_layout_with_id_raise_when_no_layout_found
+  def test_layout_should_raise_when_the_specified_layout_is_not_found
     assert_raises ThinReports::Errors::UnknownLayoutId do
-      @report.layout(:unknown)
+      @report.layout(:unknown_layout_id)
     end
   end
   
-  def test_generate
-    setup_generator do |g|
-      g.should_receive(:generate).and_return('output').once
-    end
-    assert_equal @report.generate(:pdf, {:option => :value}), 'output'
+  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_file
-    setup_generator do |g|
-      g.should_receive(:generate_file).with(String).once
-    end
-    @report.generate_file(:pdf, 'output.pdf', {:option => :value})
+  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_events
-    flexmock(@report.internal).
-      should_receive(:events).and_return(flexmock('report_events')).once
+  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.events.flexmock_name, 'report_events'
+    assert_equal @report.generate(:option => :value), 'Success'
   end
   
-  def test_page
-    flexmock(@report.internal).
-      should_receive(:page).and_return(flexmock('current_page')).once
+  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
     
-    assert_equal @report.page.flexmock_name, 'current_page'
+    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
+  end
+  
+  def test_page_should_return_the_current_page
+    @report.use_layout(data_file('basic_layout1.tlf'))
+    @report.start_new_page
+    
+    assert_instance_of ThinReports::Core::Page, @report.page
+  end
+  
+  def test_page_count_should_return_total_page_count
+    @report.use_layout(data_file('basic_layout1.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_page_count
-    assert_equal @report.page_count, 0
+  def test_finalized_asker_should_return_false_when_report_has_not_been_finalized_yet
+    assert_equal @report.finalized?, false
   end
   
-  def test_finalize
+  def test_finalized_asker_should_return_true_when_report_is_already_finalized
     @report.finalize
     assert_equal @report.finalized?, true
   end
   
-  def test_Base_create
+  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_raise_when_no_block_given
+  def test_Base_create_should_raise_when_no_block_given
     assert_raises ArgumentError do
       Report::Base.create
     end
   end
   
-  def test_Base_generate
+  def test_Base_generate_should_properly_generate_when_type_is_specified
     flexmock(Report::Base).new_instances.
-      should_receive(:generate).with(:pdf, Hash).once
+      should_receive(:generate).
+      with(:pdf, :option => :value).once
     
     flexmock(Report::Base).
-      should_receive(:create).with(Hash, Proc).
+      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_raise_when_no_block_given
-    assert_raises ArgumentError do
-      Report::Base.generate(:pdf)
-    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
+  def test_Base_generate_file_should_properly_generate_file_when_type_is_specified
     flexmock(Report::Base).new_instances.
-      should_receive(:generate_file).with(:pdf, String, Hash).once
+      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_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(Hash, Proc).
+      should_receive(:create).
+      with({}, Proc).
       and_return(Report::Base.new).once
     
-    Report::Base.generate_file(:pdf, 'output.pdf', :report    => {:layout => 'layout.tlf'},
-                                                   :generator => {:option => :value}) {}
+    Report::Base.generate_file('output.pdf', :generator => {:option => :value}) {}
   end
   
-  def test_Base_generate_file_raise_when_no_block_given
+  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_init_generate_params_with_empty_options
-    Report::Base.send(:init_generate_params, options = {}) {}
-    assert_equal options.values_at(:report, :generator), [{}, {}]
+  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'}}])
+    assert_equal report[:layout], 'hoge.tlf'
   end
   
-  def test_Base_init_generate_params_with_configured_options
-    options = {:report    => {:layout => 'layout.tlf'},
-               :generator => {:option => :value}}
-    Report::Base.send(:init_generate_params, options) {}
-    
-    assert_equal options[:report], {:layout => 'layout.tlf'}
-    assert_equal options[:generator], {:option => :value}
+  def test_Base_extract_options_should_operate_an_argument_destructively
+    args = [:pdf, 'output.pdf', {:report => {:layout => 'foo.tlf'}}]
+    Report::Base.send(:extract_options!, args)
+    assert_equal args, [:pdf, 'output.pdf']
   end
   
-  def test_Base_init_generate_params_raise_when_no_block_given
-    assert_raises ArgumentError do
-      Report::Base.send(:init_generate_params)
-    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'}])
+    assert_equal report[:layout], 'hoge.tlf'
   end
   
-  def setup_generator(&block)
-    block.call(generator = flexmock('generator'))
-    
-    flexmock(ThinReports::Generator).
-      should_receive(:new).with(:pdf, @report, Hash).and_return(generator)
+  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'}])
+    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'}}])
+    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'}])
+    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'}])
+    assert_equal generator.values_at(:generator_opt1, :generator_opt2),
+                 ['value1', 'value2']
   end
 end