axlsx 1.2.0 → 2.0.0

data/test/workbook/worksheet/tc_sheet_view.rb

@@ -5,207 +5,207 @@ require 'tc_helper.rb'
 class TestSheetView < Test::Unit::TestCase
   def setup
     #inverse defaults for booleans
-    @boolean_options = { :right_to_left => true, :show_formulas => true, :show_outline_symbols => true, 
+    @boolean_options = { :right_to_left => true, :show_formulas => true, :show_outline_symbols => true,
       :show_white_space => true, :tab_selected => true, :default_grid_color => false, :show_grid_lines => false,
       :show_row_col_headers => false, :show_ruler => false, :show_zeros => false, :window_protection => true }
     @symbol_options = { :view => :page_break_preview }
     @nil_options = { :color_id => 2, :top_left_cell => 'A2' }
     @int_0 = { :zoom_scale_normal => 100, :zoom_scale_page_layout_view => 100, :zoom_scale_sheet_layout_view => 100, :workbook_view_id => 2 }
     @int_100 = { :zoom_scale => 10 }
-    
+
     @integer_options = { :color_id => 2, :workbook_view_id => 2 }.merge(@int_0).merge(@int_100)
     @string_options = { :top_left_cell => 'A2' }
-    
-    
+
+
     @options = @boolean_options.merge(@boolean_options).merge(@symbol_options).merge(@nil_options).merge(@int_0).merge(@int_100)
-    
+
     @sv = Axlsx::SheetView.new(@options)
   end
-  
+
   def test_initialize
     sv = Axlsx::SheetView.new
-    
+
     @boolean_options.each do |key, value|
       assert_equal(!value, sv.send(key.to_sym), "initialized default #{key} should be #{!value}")
       assert_equal(value, @sv.send(key.to_sym), "initialized options #{key} should be #{value}")
     end
-    
+
     @nil_options.each do |key, value|
       assert_equal(nil, sv.send(key.to_sym), "initialized default #{key} should be nil")
       assert_equal(value, @sv.send(key.to_sym), "initialized options #{key} should be #{value}")
     end
-    
+
     @int_0.each do |key, value|
       assert_equal(0, sv.send(key.to_sym), "initialized default #{key} should be 0")
       assert_equal(value, @sv.send(key.to_sym), "initialized options #{key} should be #{value}")
     end
-    
+
     @int_100.each do |key, value|
       assert_equal(100, sv.send(key.to_sym), "initialized default #{key} should be 100")
       assert_equal(value, @sv.send(key.to_sym), "initialized options #{key} should be #{value}")
     end
   end
-  
+
   def test_boolean_attribute_validation
     @boolean_options.each do |key, value|
       assert_raise(ArgumentError, "#{key} must be boolean") { @sv.send("#{key}=".to_sym, 'A') }
       assert_nothing_raised { @sv.send("#{key}=".to_sym, true) }
     end
   end
-  
+
   def test_string_attribute_validation
     @string_options.each do |key, value|
       assert_raise(ArgumentError, "#{key} must be string") { @sv.send("#{key}=".to_sym, :symbol) }
       assert_nothing_raised { @sv.send("#{key}=".to_sym, "foo") }
     end
   end
-  
+
   def test_symbol_attribute_validation
     @symbol_options.each do |key, value|
       assert_raise(ArgumentError, "#{key} must be symbol") { @sv.send("#{key}=".to_sym, "foo") }
       assert_nothing_raised { @sv.send("#{key}=".to_sym, value) }
     end
   end
-  
+
   def test_integer_attribute_validation
     @integer_options.each do |key, value|
       assert_raise(ArgumentError, "#{key} must be integer") { @sv.send("#{key}=".to_sym, "foo") }
       assert_nothing_raised { @sv.send("#{key}=".to_sym, value) }
     end
   end
-  
+
   def test_color_id
     assert_raise(ArgumentError) { @sv.color_id = "10" }
     assert_nothing_raised { @sv.color_id = 2 }
     assert_equal(@sv.color_id, 2)
   end
-  
+
   def test_default_grid_color
     assert_raise(ArgumentError) { @sv.default_grid_color = "foo" }
     assert_nothing_raised { @sv.default_grid_color = false }
     assert_equal(@sv.default_grid_color, false)
   end
-  
+
   def test_right_to_left
     assert_raise(ArgumentError) { @sv.right_to_left = "foo´" }
     assert_nothing_raised { @sv.right_to_left = true }
     assert_equal(@sv.right_to_left, true)
   end
-  
+
   def test_show_formulas
     assert_raise(ArgumentError) { @sv.show_formulas = 'foo' }
     assert_nothing_raised { @sv.show_formulas = false }
     assert_equal(@sv.show_formulas, false)
   end
-  
+
   def test_show_grid_lines
     assert_raise(ArgumentError) { @sv.show_grid_lines = "foo" }
     assert_nothing_raised { @sv.show_grid_lines = false }
     assert_equal(@sv.show_grid_lines, false)
   end
-  
+
   def test_show_outline_symbols
     assert_raise(ArgumentError) { @sv.show_outline_symbols = 'foo' }
     assert_nothing_raised { @sv.show_outline_symbols = false }
     assert_equal(@sv.show_outline_symbols, false)
   end
-  
+
   def test_show_row_col_headers
     assert_raise(ArgumentError) { @sv.show_row_col_headers = "foo" }
     assert_nothing_raised { @sv.show_row_col_headers = false }
     assert_equal(@sv.show_row_col_headers, false)
   end
-  
+
   def test_show_ruler
     assert_raise(ArgumentError) { @sv.show_ruler = 'foo' }
     assert_nothing_raised { @sv.show_ruler = false }
     assert_equal(@sv.show_ruler, false)
   end
-  
+
   def test_show_white_space
     assert_raise(ArgumentError) { @sv.show_white_space = 'foo' }
     assert_nothing_raised { @sv.show_white_space = false }
     assert_equal(@sv.show_white_space, false)
   end
-  
+
   def test_show_zeros
     assert_raise(ArgumentError) { @sv.show_zeros = "foo" }
     assert_nothing_raised { @sv.show_zeros = false }
     assert_equal(@sv.show_zeros, false)
   end
-  
+
   def test_tab_selected
     assert_raise(ArgumentError) { @sv.tab_selected = "foo" }
     assert_nothing_raised { @sv.tab_selected = false }
     assert_equal(@sv.tab_selected, false)
   end
-  
+
   def test_top_left_cell
     assert_raise(ArgumentError) { @sv.top_left_cell = :cell_adress }
     assert_nothing_raised { @sv.top_left_cell = "A2" }
     assert_equal(@sv.top_left_cell, "A2")
   end
-  
+
   def test_view
     assert_raise(ArgumentError) { @sv.view = 'view' }
     assert_nothing_raised { @sv.view = :page_break_preview }
     assert_equal(@sv.view, :page_break_preview)
   end
-  
+
   def test_window_protection
     assert_raise(ArgumentError) { @sv.window_protection = "foo" }
     assert_nothing_raised { @sv.window_protection = false }
     assert_equal(@sv.window_protection, false)
   end
-  
+
   def test_workbook_view_id
     assert_raise(ArgumentError) { @sv.workbook_view_id = "1" }
     assert_nothing_raised { @sv.workbook_view_id = 1 }
     assert_equal(@sv.workbook_view_id, 1)
   end
-  
+
   def test_zoom_scale
     assert_raise(ArgumentError) { @sv.zoom_scale = "50" }
     assert_nothing_raised { @sv.zoom_scale = 50 }
     assert_equal(@sv.zoom_scale, 50)
   end
-  
+
   def test_zoom_scale_normal
     assert_raise(ArgumentError) { @sv.zoom_scale_normal = "50" }
     assert_nothing_raised { @sv.zoom_scale_normal = 50 }
     assert_equal(@sv.zoom_scale_normal, 50)
   end
-  
+
   def test_zoom_scale_page_layout_view
     assert_raise(ArgumentError) { @sv.zoom_scale_page_layout_view = "50" }
     assert_nothing_raised { @sv.zoom_scale_page_layout_view = 50 }
     assert_equal(@sv.zoom_scale_page_layout_view, 50)
   end
-  
+
   def test_zoom_scale_sheet_layout_view
     assert_raise(ArgumentError) { @sv.zoom_scale_sheet_layout_view = "50" }
     assert_nothing_raised { @sv.zoom_scale_sheet_layout_view = 50 }
     assert_equal(@sv.zoom_scale_sheet_layout_view, 50)
   end
-  
+
   def test_to_xml
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name => "sheetview"
     @ws.sheet_view do |vs|
       vs.view = :page_break_preview
     end
-    
+
     doc = Nokogiri::XML.parse(@ws.sheet_view.to_xml_string)
-    
+
     assert_equal(1, doc.xpath("//sheetView[@tabSelected='false']").size)
-    
+
     assert_equal(1, doc.xpath("//sheetView[@tabSelected='false'][@showWhiteSpace='false'][@showOutlineSymbols='false'][@showFormulas='false']
         [@rightToLeft='false'][@windowProtection='false'][@showZeros='true'][@showRuler='true']
         [@showRowColHeaders='true'][@showGridLines='true'][@defaultGridColor='true']
         [@zoomScale='100'][@workbookViewId='0'][@zoomScaleSheetLayoutView='0'][@zoomScalePageLayoutView='0']
-        [@zoomScaleNormal='0'][@view='page_break_preview']").size)
+        [@zoomScaleNormal='0'][@view='pageBreakPreview']").size)
   end
-  
+
   def test_add_selection
      @sv.add_selection(:top_left, :active_cell => "A1")
      assert_equal('A1', @sv.selections[:top_left].active_cell)

data/test/workbook/worksheet/{table/tc_table.rb → tc_table.rb}

@@ -15,6 +15,12 @@ class TestTable < Test::Unit::TestCase
 
   end
 
+  def test_table_style_info
+    table = @ws.add_table('A1:D5', :name => 'foo', :style_info => { :show_row_stripes => true, :name => "TableStyleMedium25" })
+    assert_equal('TableStyleMedium25', table.table_style_info.name)
+    assert_equal(true, table.table_style_info.show_row_stripes)
+  end
+
   def test_add_table
     name = "test"
     table = @ws.add_table("A1:D5", :name => name)
@@ -22,7 +28,6 @@ class TestTable < Test::Unit::TestCase
     assert_equal(@ws.workbook.tables.last, table, "must be added to workbook table collection")
     assert_equal(@ws.tables.last, table, "must be added to worksheet table collection")
     assert_equal(table.name, name, "options for name are applied")
-
   end
 
   def test_pn
@@ -31,8 +36,8 @@ class TestTable < Test::Unit::TestCase
   end
 
   def test_rId
-    @ws.add_table("A1:D5")
-    assert_equal(@ws.tables.first.rId, "rId1")
+    table = @ws.add_table("A1:D5")
+    assert_equal @ws.relationships.for(table).Id, table.rId
   end
 
   def test_index

data/test/workbook/worksheet/tc_table_style_info.rb

@@ -0,0 +1,53 @@
+require 'tc_helper.rb'
+
+class TestTableStyleInfo < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+    40.times do 
+      @ws.add_row %w(aa bb cc dd ee ff gg hh ii jj kk)
+    end
+    @table = @ws.add_table(Axlsx::cell_range([@ws.rows.first.cells.first,@ws.rows.last.cells.last], false), :name => 'foo')
+    @options =  { :show_first_column => 1,
+                :show_last_column => 1,
+                :show_row_stripes => 1,
+                :show_column_stripes => 1,
+                :name => "TableStyleDark4" }
+
+
+  end
+
+  def test_initialize
+    table_style = Axlsx::TableStyleInfo.new @options
+    @options.each do |key, value|
+      assert_equal(value, table_style.send(key.to_sym))
+    end
+  end
+
+  def test_boolean_properties
+    table_style = Axlsx::TableStyleInfo.new
+    @options.keys.each do |key|
+     assert_nothing_raised { table_style.send("#{key.to_sym}=", true) }
+     assert_raises(ArgumentError) { table_style.send(key.to_sym, 'foo') }
+    end
+  end
+  def doc
+    @doc ||= Nokogiri::XML(Axlsx::TableStyleInfo.new(@options).to_xml_string)
+  end
+
+  def test_to_xml_string_first_column
+    assert(doc.xpath('//tableStyleInfo[@showLastColumn=1]'))
+  end
+
+  def test_to_xml_string_row_stripes
+    assert(doc.xpath('//tableStyleInfo[@showRowStripes=1]'))
+  end
+
+  def test_to_xml_string_column_stripes
+    assert(doc.xpath('//tableStyleInfo[@showColumnStripes=1]'))
+  end
+
+  def test_to_xml_string_name
+    assert(doc.xpath("//tableStyleInfo[@name=#{@options[:name]}]"))
+  end
+end

data/test/workbook/worksheet/tc_worksheet.rb

@@ -19,9 +19,16 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(@ws.name, '&lt;foo&gt; &amp; &lt;bar&gt;')
   end
 
-  def test_name_exception_on_colon
+  def test_name_exception_on_invalid_character
     assert_raises(ArgumentError) { @ws.name = 'foo:bar' }
+    assert_raises(ArgumentError) { @ws.name = 'foo[bar' }
+    assert_raises(ArgumentError) { @ws.name = 'foo]bar' }
+    assert_raises(ArgumentError) { @ws.name = 'foo*bar' }
+    assert_raises(ArgumentError) { @ws.name = 'foo/bar' }
+    assert_raises(ArgumentError) { @ws.name = 'foo\bar' }
+    assert_raises(ArgumentError) { @ws.name = 'foo?bar' }
   end
+
   def test_page_margins
     assert(@ws.page_margins.is_a? Axlsx::PageMargins)
   end
@@ -55,6 +62,17 @@ class TestWorksheet < Test::Unit::TestCase
     end
   end
 
+  def test_header_footer
+    assert(@ws.header_footer.is_a? Axlsx::HeaderFooter)
+  end
+
+  def test_header_footer_yield
+    @ws.header_footer do |hf|
+      assert(hf.is_a? Axlsx::HeaderFooter)
+      assert(@ws.header_footer == hf)
+    end
+  end
+
   def test_no_autowidth
     @ws.workbook.use_autowidth = false
     @ws.add_row [1,2,3,4]
@@ -65,7 +83,8 @@ class TestWorksheet < Test::Unit::TestCase
     page_margins = {:left => 2, :right => 2, :bottom => 2, :top => 2, :header => 2, :footer => 2}
     page_setup = {:fit_to_height => 1, :fit_to_width => 1, :orientation => :landscape, :paper_width => "210mm", :paper_height => "297mm", :scale => 80}
     print_options = {:grid_lines => true, :headings => true, :horizontal_centered => true, :vertical_centered => true}
-    optioned = @ws.workbook.add_worksheet(:name => 'bob', :page_margins => page_margins, :page_setup => page_setup, :print_options => print_options, :selected => true, :show_gridlines => false)
+    header_footer = {:different_first => false, :different_odd_even => false, :odd_header => 'Header'}
+    optioned = @ws.workbook.add_worksheet(:name => 'bob', :page_margins => page_margins, :page_setup => page_setup, :print_options => print_options, :header_footer => header_footer, :selected => true, :show_gridlines => false)
     page_margins.keys.each do |key|
       assert_equal(page_margins[key], optioned.page_margins.send(key))
     end
@@ -75,6 +94,9 @@ class TestWorksheet < Test::Unit::TestCase
     print_options.keys.each do |key|
       assert_equal(print_options[key], optioned.print_options.send(key))
     end
+    header_footer.keys.each do |key|
+      assert_equal(header_footer[key], optioned.header_footer.send(key))
+    end
     assert_equal(optioned.name, 'bob')
     assert_equal(optioned.selected, true)
     assert_equal(optioned.show_gridlines, false)
@@ -101,9 +123,7 @@ class TestWorksheet < Test::Unit::TestCase
   end
 
   def test_rId
-    assert_equal(@ws.rId, "rId1")
-    ws = @ws.workbook.add_worksheet
-    assert_equal(ws.rId, "rId2")
+    assert_equal @ws.workbook.relationships.for(@ws).Id, @ws.rId
   end
 
   def test_index
@@ -147,12 +167,39 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(@ws.workbook.charts.size, 1, "add_chart adds a chart to the workbook")
   end
 
+  def test_add_page_break_with_string_cell_ref
+    assert(@ws.row_breaks.empty?)
+    assert(@ws.col_breaks.empty?)
+    @ws.add_page_break("B1")
+    assert_equal(1, @ws.row_breaks.size)
+    assert_equal(1, @ws.col_breaks.size)
+  end
+
+  def test_add_page_break_with_cell
+    @ws.add_row [1, 2, 3, 4]
+    @ws.add_row [1, 2, 3, 4]
+
+
+    assert(@ws.row_breaks.empty?)
+    assert(@ws.col_breaks.empty?)
+    @ws.add_page_break(@ws.rows.last.cells[1])
+    assert_equal(1, @ws.row_breaks.size)
+    assert_equal(1, @ws.col_breaks.size)
+  end
+
+
   def test_drawing
     assert @ws.drawing == nil
     @ws.add_chart(Axlsx::Pie3DChart)
     assert @ws.drawing.is_a?(Axlsx::Drawing)
   end
 
+  def test_add_pivot_table
+    assert(@ws.workbook.pivot_tables.empty?, "the sheet's workbook should not have any pivot tables by default")
+    @ws.add_pivot_table 'G5:G6', 'A1:D:10'
+    assert_equal(@ws.workbook.pivot_tables.size, 1, "add_pivot_tables adds a pivot_table to the workbook")
+  end
+
   def test_col_style
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
@@ -177,13 +224,20 @@ class TestWorksheet < Test::Unit::TestCase
   def test_cols
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
+    @ws.add_row [1,2,3]
     @ws.add_row [1,2,3,4]
     c = @ws.cols[1]
     assert_equal(c.size, 4)
     assert_equal(c[0].value, 2)
   end
 
+  def test_cols_with_block
+    @ws.add_row [1,2,3]
+    @ws.add_row [1]
+    cols = @ws.cols {|row, column| :foo }
+    assert_equal(:foo, cols[1][1])
+  end
+
   def test_row_style
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
@@ -246,7 +300,7 @@ class TestWorksheet < Test::Unit::TestCase
 
   def test_to_xml_string_auto_filter
     @ws.add_row [1, "two"]
-    @ws.auto_filter = "A1:B1"
+    @ws.auto_filter.range = "A1:B1"
     doc = Nokogiri::XML(@ws.to_xml_string)
     assert_equal(doc.xpath('//xmlns:worksheet/xmlns:autoFilter[@ref="A1:B1"]').size, 1)
   end
@@ -260,6 +314,12 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(doc.xpath('//xmlns:worksheet/xmlns:mergeCells/xmlns:mergeCell[@ref="E1:F1"]').size, 1)
   end
 
+  def test_to_xml_string_row_breaks
+  @ws.add_page_break("A1")
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:rowBreaks/xmlns:brk[@id="0"]').size, 1)
+  end
+
   def test_to_xml_string_sheet_protection
     @ws.sheet_protection.password = 'fish'
     doc = Nokogiri::XML(@ws.to_xml_string)
@@ -293,19 +353,29 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(doc.xpath('//xmlns:worksheet/xmlns:printOptions[@gridLines="true"][@horizontalCentered="true"]').size, 1)
   end
 
+  def test_to_xml_string_header_footer
+    @ws.header_footer do |hf|
+      hf.different_first = false
+      hf.different_odd_even = false
+      hf.odd_header = 'Test Header'
+    end
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:headerFooter[@differentFirst="false"][@differentOddEven="false"]').size, 1)
+  end
+
   def test_to_xml_string_drawing
     @ws.add_chart Axlsx::Pie3DChart
     doc = Nokogiri::XML(@ws.to_xml_string)
-    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:drawing[@r:id="rId1"]').size, 1)
+    assert_equal @ws.send(:worksheet_drawing).relationship.Id, doc.xpath('//xmlns:worksheet/xmlns:drawing').first["r:id"]
   end
 
   def test_to_xml_string_tables
     @ws.add_row ["one", "two"]
     @ws.add_row [1, 2]
-    @ws.add_table "A1:B2"
+    table = @ws.add_table "A1:B2"
     doc = Nokogiri::XML(@ws.to_xml_string)
     assert_equal(doc.xpath('//xmlns:worksheet/xmlns:tableParts[@count="1"]').size, 1)
-    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:tableParts/xmlns:tablePart[@r:id="rId1"]').size, 1)
+    assert_equal table.rId, doc.xpath('//xmlns:worksheet/xmlns:tableParts/xmlns:tablePart').first["r:id"]
   end
 
   def test_to_xml_string
@@ -317,23 +387,31 @@ class TestWorksheet < Test::Unit::TestCase
   def test_styles
     assert(@ws.styles.is_a?(Axlsx::Styles), 'worksheet provides access to styles')
   end
-  
+
   def test_to_xml_string_with_illegal_chars
     nasties =  "\v\u2028\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u001f"
     @ws.add_row [nasties]
     assert_equal(0, @ws.rows.last.cells.last.value.index("\v"))
     assert_equal(nil,@ws.to_xml_string.index("\v"))
   end
+
+  def test_to_xml_string_with_newlines
+    cell_with_newline = "foo\n\r\nbar"
+    @ws.add_row [cell_with_newline]
+    assert_equal("foo\n\r\nbar", @ws.rows.last.cells.last.value)
+    assert_not_nil(@ws.to_xml_string.index("foo\n\r\nbar"))
+  end
   # Make sure the XML for all optional elements (like pageMargins, autoFilter, ...)
   # is generated in correct order.
   def test_valid_with_optional_elements
     @ws.page_margins.set :left => 9
     @ws.page_setup.set :fit_to_width => 1
     @ws.print_options.set :headings => true
-    @ws.auto_filter = "A1:C3"
+    @ws.auto_filter.range = "A1:C3"
     @ws.merge_cells "A4:A5"
     @ws.add_chart Axlsx::Pie3DChart
     @ws.add_table "E1:F3"
+    @ws.add_pivot_table  'G5:G6', 'A1:D10'
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
     doc = Nokogiri::XML(@ws.to_xml_string)
     assert(schema.validate(doc).map { |e| puts e.message; e }.empty?, schema.validate(doc).map { |e| e.message }.join('\n'))
@@ -350,6 +428,8 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(@ws.relationships.size, 4, "adding a comment adds 3 relationships")
     c = @ws.add_comment :text => 'not that is a comment!', :author => 'travis', :ref => "A1"
     assert_equal(@ws.relationships.size, 4, "adding multiple comments in the same worksheet should not add any additional comment relationships")
+    c = @ws.add_pivot_table 'G5:G6', 'A1:D10'
+    assert_equal(@ws.relationships.size, 5, "adding a pivot table adds 1 relationship")
   end
 
 
@@ -357,6 +437,11 @@ class TestWorksheet < Test::Unit::TestCase
     assert_raise(ArgumentError, "worksheet name must be unique") { n = @ws.name; @ws.workbook.add_worksheet(:name=> n) }
   end
 
+  def test_name_unique_only_checks_other_worksheet_names
+    assert_nothing_raised { @ws.name = @ws.name }
+    assert_nothing_raised { Axlsx::Package.new.workbook.add_worksheet :name => 'Sheet1' }
+  end
+
   def test_name_size
     assert_raise(ArgumentError, "name too long!") { @ws.name = Array.new(32, "A").join() }
     assert_nothing_raised { @ws.name = Array.new(31, "A").join() }
@@ -393,7 +478,7 @@ class TestWorksheet < Test::Unit::TestCase
     @ws.add_row [1, 2, 3]
     assert_nothing_raised {@ws.protect_range(@ws.rows.first.cells) }
     assert_equal('A1:C1', @ws.send(:protected_ranges).last.sqref)
-    
+
   end
   def test_merge_cells
     @ws.add_row [1,2,3]
@@ -405,7 +490,7 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(@ws.send(:merged_cells).size, 3)
     assert_equal(@ws.send(:merged_cells).last, "A3:B3")
   end
-  
+
   def test_merge_cells_sorts_correctly_by_row_when_given_array
     10.times do |i|
       @ws.add_row [i]
@@ -413,11 +498,41 @@ class TestWorksheet < Test::Unit::TestCase
     @ws.merge_cells [@ws.rows[8].cells.first, @ws.rows[9].cells.first]
     assert_equal "A9:A10", @ws.send(:merged_cells).first
   end
-  
+
   def test_auto_filter
     assert(@ws.auto_filter.range.nil?)
     assert_raise(ArgumentError) { @ws.auto_filter = 123 }
-    @ws.auto_filter = "A1:D9"
+    @ws.auto_filter.range = "A1:D9"
     assert_equal(@ws.auto_filter.range, "A1:D9")
   end
+
+  def test_sheet_pr_for_auto_filter
+    @ws.auto_filter.range = 'A1:D9'
+    @ws.auto_filter.add_column 0, :filters, :filter_items => [1]
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert(doc.xpath('//sheetPr[@filterMode="true"]'))
+  end
+
+  def test_outline_level_rows
+    3.times { @ws.add_row [1,2,3] }
+    @ws.outline_level_rows 0, 2
+    assert_equal(1, @ws.rows[0].outline_level)
+    assert_equal(true, @ws.rows[2].hidden)
+    assert_equal(true, @ws.sheet_view.show_outline_symbols)
+  end
+
+  def test_outline_level_columns
+    3.times { @ws.add_row [1,2,3] }
+    @ws.outline_level_columns 0, 2
+    assert_equal(1, @ws.column_info[0].outline_level)
+    assert_equal(true, @ws.column_info[2].hidden)
+    assert_equal(true, @ws.sheet_view.show_outline_symbols)
+  end
+
+  def test_worksheet_does_not_get_added_to_workbook_on_initialize_failure
+    assert_equal(1, @wb.worksheets.size)
+    assert_raise(ArgumentError) { @wb.add_worksheet(:name => 'Sheet1') }
+    assert_equal(1, @wb.worksheets.size)
+  end
+
 end

data/test/workbook/worksheet/tc_worksheet_hyperlink.rb

@@ -0,0 +1,55 @@
+require 'tc_helper.rb'
+
+class TestWorksheetHyperlink < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    wb = p.workbook
+    @ws = wb.add_worksheet
+    @options = { :location => 'https://github.com/randym/axlsx?foo=1&bar=2', :tooltip => 'axlsx', :ref => 'A1', :display => 'AXSLX', :target => :internal }
+    @a = @ws.add_hyperlink @options
+  end
+
+  def test_initailize
+    assert_raise(ArgumentError) { Axlsx::WorksheetHyperlink.new }
+  end
+
+  def test_location
+    assert_equal(@options[:location], @a.location)
+  end
+
+  def test_tooltip
+    assert_equal(@options[:tooltip], @a.tooltip)
+  end
+
+  def test_target
+    assert_equal(@options[:target], @a.instance_values['target'])
+  end
+
+  def test_display
+    assert_equal(@options[:display], @a.display)
+  end
+  def test_ref
+    assert_equal(@options[:ref], @a.ref)
+  end
+
+  def test_to_xml_string_with_non_external
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@ref='#{@a.ref}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@tooltip='#{@a.tooltip}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@location='#{@a.location}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@display='#{@a.display}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@r:id]").size, 0)
+  end
+
+  def test_to_xml_stirng_with_external
+    @a.target = :external
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@ref='#{@a.ref}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@tooltip='#{@a.tooltip}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@display='#{@a.display}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@location='#{@a.location}']").size, 0)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@r:id='#{@a.relationship.Id}']").size, 1)
+  end
+end
+
+