bonio-axlsx 2.2.1

data/test/workbook/worksheet/tc_icon_set.rb

@@ -0,0 +1,45 @@
+require 'tc_helper.rb'
+
+class TestIconSet < Test::Unit::TestCase
+  def setup
+    @icon_set = Axlsx::IconSet.new
+  end
+
+  def test_defaults
+    assert_equal @icon_set.iconSet, "3TrafficLights1"
+    assert_equal @icon_set.percent, true
+    assert_equal @icon_set.reverse, false
+    assert_equal @icon_set.showValue, true
+  end
+
+  def test_icon_set
+    assert_raise(ArgumentError) { @icon_set.iconSet = "invalid_value" }
+    assert_nothing_raised { @icon_set.iconSet = "5Rating"}
+    assert_equal(@icon_set.iconSet, "5Rating")
+  end
+
+  def test_percent
+    assert_raise(ArgumentError) { @icon_set.percent = :invalid_type }
+    assert_nothing_raised { @icon_set.percent =  false}
+    assert_equal(@icon_set.percent, false)
+  end
+
+  def test_showValue
+    assert_raise(ArgumentError) { @icon_set.showValue = :invalid_type }
+    assert_nothing_raised { @icon_set.showValue =  false}
+    assert_equal(@icon_set.showValue, false)
+  end
+
+  def test_reverse
+    assert_raise(ArgumentError) { @icon_set.reverse = :invalid_type }
+    assert_nothing_raised { @icon_set.reverse =  false}
+    assert_equal(@icon_set.reverse, false)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML.parse(@icon_set.to_xml_string)
+    assert_equal(doc.xpath(".//iconSet[@iconSet='3TrafficLights1'][@percent=1][@reverse=0][@showValue=1]").size, 1)
+    assert_equal(doc.xpath(".//iconSet//cfvo").size, 3)
+  end
+
+end

data/test/workbook/worksheet/tc_outline_pr.rb

@@ -0,0 +1,19 @@
+require 'tc_helper.rb'
+
+class TestOutlinePr < Test::Unit::TestCase
+ def setup
+   @outline_pr = Axlsx::OutlinePr.new(:summary_below => false, :summary_right => true, :apply_styles => false)
+ end
+
+ def test_summary_below
+   assert_equal false, @outline_pr.summary_below
+ end
+
+ def test_summary_right
+   assert_equal true, @outline_pr.summary_right
+ end
+ 
+ def test_apply_styles
+   assert_equal false, @outline_pr.apply_styles
+ end
+end

data/test/workbook/worksheet/tc_page_margins.rb

@@ -0,0 +1,97 @@
+require 'tc_helper.rb'
+
+class TestPageMargins < Test::Unit::TestCase
+
+  def setup
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet :name=>"hmmm"
+    @pm = ws.page_margins
+  end
+
+  def test_initialize
+    assert_equal(Axlsx::PageMargins::DEFAULT_LEFT_RIGHT, @pm.left)
+    assert_equal(Axlsx::PageMargins::DEFAULT_LEFT_RIGHT, @pm.right)
+    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.top)
+    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.bottom)
+    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.header)
+    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.footer)
+  end
+
+  def test_initialize_with_options
+    optioned = Axlsx::PageMargins.new(:left => 2, :right => 3, :top => 2, :bottom => 1, :header => 0.1, :footer => 0.1)
+    assert_equal(2, optioned.left)
+    assert_equal(3, optioned.right)
+    assert_equal(2, optioned.top)
+    assert_equal(1, optioned.bottom)
+    assert_equal(0.1, optioned.header)
+    assert_equal(0.1, optioned.footer)
+  end
+
+
+  def test_set_all_values
+    @pm.set(:left => 1.1, :right => 1.2, :top => 1.3, :bottom => 1.4, :header => 0.8, :footer => 0.9)
+    assert_equal(1.1, @pm.left)
+    assert_equal(1.2, @pm.right)
+    assert_equal(1.3, @pm.top)
+    assert_equal(1.4, @pm.bottom)
+    assert_equal(0.8, @pm.header)
+    assert_equal(0.9, @pm.footer)
+  end
+
+  def test_set_some_values
+    @pm.set(:left => 1.1, :right => 1.2)
+    assert_equal(1.1, @pm.left)
+    assert_equal(1.2, @pm.right)
+    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.top)
+    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.bottom)
+    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.header)
+    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.footer)
+  end
+
+  def test_to_xml
+    @pm.left = 1.1
+    @pm.right = 1.2
+    @pm.top = 1.3
+    @pm.bottom = 1.4
+    @pm.header = 0.8
+    @pm.footer = 0.9
+    doc = Nokogiri::XML.parse(@pm.to_xml_string)
+    assert_equal(1, doc.xpath(".//pageMargins[@left=1.1][@right=1.2][@top=1.3][@bottom=1.4][@header=0.8][@footer=0.9]").size)
+  end
+
+  def test_left
+    assert_raise(ArgumentError) { @pm.left = -1.2 }
+    assert_nothing_raised { @pm.left = 1.5 }
+    assert_equal(@pm.left, 1.5)
+  end
+
+  def test_right
+    assert_raise(ArgumentError) { @pm.right = -1.2 }
+    assert_nothing_raised { @pm.right = 1.5 }
+    assert_equal(@pm.right, 1.5)
+  end
+
+  def test_top
+    assert_raise(ArgumentError) { @pm.top = -1.2 }
+    assert_nothing_raised { @pm.top = 1.5 }
+    assert_equal(@pm.top, 1.5)
+  end
+
+  def test_bottom
+    assert_raise(ArgumentError) { @pm.bottom = -1.2 }
+    assert_nothing_raised { @pm.bottom = 1.5 }
+    assert_equal(@pm.bottom, 1.5)
+  end
+
+  def test_header
+    assert_raise(ArgumentError) { @pm.header = -1.2 }
+    assert_nothing_raised { @pm.header = 1.5 }
+    assert_equal(@pm.header, 1.5)
+  end
+
+  def test_footer
+    assert_raise(ArgumentError) { @pm.footer = -1.2 }
+    assert_nothing_raised { @pm.footer = 1.5 }
+    assert_equal(@pm.footer, 1.5)
+  end
+end

data/test/workbook/worksheet/tc_page_set_up_pr.rb

@@ -0,0 +1,15 @@
+require 'tc_helper.rb'
+
+class TestPageSetUpPr < Test::Unit::TestCase
+ def setup
+   @page_setup_pr = Axlsx::PageSetUpPr.new(:fit_to_page => true, :auto_page_breaks => true)
+ end
+
+ def test_fit_to_page
+   assert_equal true, @page_setup_pr.fit_to_page
+ end
+
+ def test_auto_page_breaks
+   assert_equal true, @page_setup_pr.auto_page_breaks
+ end
+end

data/test/workbook/worksheet/tc_page_setup.rb

@@ -0,0 +1,143 @@
+require 'tc_helper.rb'
+
+class TestPageSetup < Test::Unit::TestCase
+
+  def setup
+    @p = Axlsx::Package.new
+    ws = @p.workbook.add_worksheet :name => "hmmm"
+    @ps = ws.page_setup
+  end
+
+  def test_initialize
+    assert_equal(nil, @ps.fit_to_height)
+    assert_equal(nil, @ps.fit_to_width)
+    assert_equal(nil, @ps.orientation)
+    assert_equal(nil, @ps.paper_height)
+    assert_equal(nil, @ps.paper_width)
+    assert_equal(nil, @ps.scale)
+  end
+
+  def test_initialize_with_options
+    page_setup = { :fit_to_height => 1,
+                   :fit_to_width => 2,
+                   :orientation => :landscape,
+                   :paper_height => "297mm",
+                   :paper_width => "210mm",
+                   :scale => 50 }
+
+    optioned = @p.workbook.add_worksheet(:name => 'optioned', :page_setup => page_setup).page_setup
+    assert_equal(1, optioned.fit_to_height)
+    assert_equal(2, optioned.fit_to_width)
+    assert_equal(:landscape, optioned.orientation)
+    assert_equal("297mm", optioned.paper_height)
+    assert_equal("210mm", optioned.paper_width)
+    assert_equal(50, optioned.scale)
+  end
+
+  def test_set_all_values
+    @ps.set(:fit_to_height => 1, :fit_to_width => 2, :orientation => :landscape, :paper_height => "297mm", :paper_width => "210mm", :scale => 50)
+    assert_equal(1, @ps.fit_to_height)
+    assert_equal(2, @ps.fit_to_width)
+    assert_equal(:landscape, @ps.orientation)
+    assert_equal("297mm", @ps.paper_height)
+    assert_equal("210mm", @ps.paper_width)
+    assert_equal(50, @ps.scale)
+  end
+
+  def test_paper_size
+    assert_raise(ArgumentError) { @ps.paper_size = 119 }
+    assert_nothing_raised {  @ps.paper_size = 10 }
+  end
+
+  def test_set_some_values
+    @ps.set(:fit_to_width => 2, :orientation => :portrait)
+    assert_equal(2, @ps.fit_to_width)
+    assert_equal(:portrait, @ps.orientation)
+    assert_equal(nil, @ps.fit_to_height)
+    assert_equal(nil, @ps.paper_height)
+    assert_equal(nil, @ps.paper_width)
+    assert_equal(nil, @ps.scale)
+  end
+
+  def test_default_fit_to_page?
+    assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
+    assert(@ps.fit_to_page? == false)
+  end
+
+  def test_with_height_fit_to_page?
+    assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
+    @ps.set(:fit_to_height => 1)
+    assert(@ps.fit_to_page?)
+  end
+
+  def test_with_width_fit_to_page?
+    assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
+    @ps.set(:fit_to_width => 1)
+    assert(@ps.fit_to_page?)
+  end
+
+  def test_to_xml_all_values
+    @ps.set(:fit_to_height => 1, :fit_to_width => 2, :orientation => :landscape, :paper_height => "297mm", :paper_width => "210mm", :scale => 50)
+    doc = Nokogiri::XML.parse(@ps.to_xml_string)
+    assert_equal(1, doc.xpath(".//pageSetup[@fitToHeight='1'][@fitToWidth='2'][@orientation='landscape'][@paperHeight='297mm'][@paperWidth='210mm'][@scale='50']").size)
+  end
+
+  def test_to_xml_some_values
+    @ps.set(:orientation => :portrait)
+    doc = Nokogiri::XML.parse(@ps.to_xml_string)
+    assert_equal(1, doc.xpath(".//pageSetup[@orientation='portrait']").size)
+    assert_equal(0, doc.xpath(".//pageSetup[@fitToHeight]").size)
+    assert_equal(0, doc.xpath(".//pageSetup[@fitToWidth]").size)
+    assert_equal(0, doc.xpath(".//pageSetup[@paperHeight]").size)
+    assert_equal(0, doc.xpath(".//pageSetup[@paperWidth]").size)
+    assert_equal(0, doc.xpath(".//pageSetup[@scale]").size)
+  end
+
+  def test_fit_to_height
+    assert_raise(ArgumentError) { @ps.fit_to_height = 1.5 }
+    assert_nothing_raised { @ps.fit_to_height = 2 }
+    assert_equal(2, @ps.fit_to_height)
+  end
+
+  def test_fit_to_width
+    assert_raise(ArgumentError) { @ps.fit_to_width = false }
+    assert_nothing_raised { @ps.fit_to_width = 1 }
+    assert_equal(1, @ps.fit_to_width)
+  end
+
+  def test_orientation
+    assert_raise(ArgumentError) { @ps.orientation = "" }
+    assert_nothing_raised { @ps.orientation = :default }
+    assert_equal(:default, @ps.orientation)
+  end
+
+  def test_paper_height
+    assert_raise(ArgumentError) { @ps.paper_height = 99 }
+    assert_nothing_raised { @ps.paper_height = "11in" }
+    assert_equal("11in", @ps.paper_height)
+  end
+
+  def test_paper_width
+    assert_raise(ArgumentError) { @ps.paper_width = "22" }
+    assert_nothing_raised { @ps.paper_width = "29.7cm" }
+    assert_equal("29.7cm", @ps.paper_width)
+  end
+
+  def test_scale
+    assert_raise(ArgumentError) { @ps.scale = 50.5 }
+    assert_nothing_raised { @ps.scale = 99 }
+    assert_equal(99, @ps.scale)
+  end
+
+  def test_fit_to
+    fits = @ps.fit_to(:width => 1)
+    assert_equal([1, 999], fits)
+    fits = @ps.fit_to :height => 1
+    assert_equal(fits, [999 ,1])
+    fits = @ps.fit_to :height => 7, :width => 2
+    assert_equal(fits, [2, 7])
+    assert_raise(ArgumentError) { puts @ps.fit_to(:width => true)}
+
+
+  end
+end

data/test/workbook/worksheet/tc_pane.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../../"
+require 'tc_helper.rb'
+
+class TestPane < Test::Unit::TestCase
+  def setup
+    #inverse defaults for booleans
+    @nil_options = { :active_pane => :bottom_left, :state => :frozen, :top_left_cell => 'A2' }
+    @int_0_options = { :x_split => 2, :y_split => 2 }
+   @options = @nil_options.merge(@int_0_options)
+    @pane = Axlsx::Pane.new(@options)
+  end
+
+
+  def test_active_pane
+    assert_raise(ArgumentError) { @pane.active_pane = "10" }
+    assert_nothing_raised { @pane.active_pane = :top_left }
+    assert_equal(@pane.active_pane, "topLeft")
+  end
+  
+  def test_state
+    assert_raise(ArgumentError) { @pane.state = "foo" }
+    assert_nothing_raised { @pane.state = :frozen_split }
+    assert_equal(@pane.state, "frozenSplit")
+  end
+  
+  def test_x_split
+    assert_raise(ArgumentError) { @pane.x_split = "foo´" }
+    assert_nothing_raised { @pane.x_split = 200 }
+    assert_equal(@pane.x_split, 200)
+  end
+  
+  def test_y_split
+    assert_raise(ArgumentError) { @pane.y_split = 'foo' }
+    assert_nothing_raised { @pane.y_split = 300 }
+    assert_equal(@pane.y_split, 300)
+  end
+  
+  def test_top_left_cell
+    assert_raise(ArgumentError) { @pane.top_left_cell = :cell }
+    assert_nothing_raised { @pane.top_left_cell = "A2" }
+    assert_equal(@pane.top_left_cell, "A2")
+  end
+  
+  def test_to_xml
+    doc = Nokogiri::XML.parse(@pane.to_xml_string)
+    assert_equal(1, doc.xpath("//pane[@ySplit=2][@xSplit='2'][@topLeftCell='A2'][@state='frozen'][@activePane='bottomLeft']").size)
+  end
+  def test_to_xml_frozen
+    pane = Axlsx::Pane.new :state => :frozen, :y_split => 2
+    doc = Nokogiri::XML(pane.to_xml_string)
+    assert_equal(1, doc.xpath("//pane[@topLeftCell='A3']").size)
+  end
+end

data/test/workbook/worksheet/tc_pivot_table.rb

@@ -0,0 +1,140 @@
+require 'tc_helper.rb'
+
+
+def shared_test_pivot_table_xml_validity(pivot_table)
+  schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+  doc = Nokogiri::XML(pivot_table.to_xml_string)
+  errors = []
+  schema.validate(doc).each do |error|
+    errors.push error
+    puts error.message
+  end
+  assert(errors.empty?, "error free validation")
+end
+
+class TestPivotTable < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+
+    @ws << ["Year","Month","Region", "Type", "Sales"]
+    @ws << [2012,  "Nov",  "East",   "Soda", "12345"]
+  end
+
+  def test_initialization
+    assert(@ws.workbook.pivot_tables.empty?)
+    assert(@ws.pivot_tables.empty?)
+  end
+
+  def test_add_pivot_table
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal('G5:G6', pivot_table.ref, 'ref assigned from first parameter')
+    assert_equal('A1:D5', pivot_table.range, 'range assigned from second parameter')
+    assert_equal('PivotTable1', pivot_table.name, 'name automatically generated')
+    assert(pivot_table.is_a?(Axlsx::PivotTable), "must create a pivot table")
+    assert_equal(@ws.workbook.pivot_tables.last, pivot_table, "must be added to workbook pivot tables collection")
+    assert_equal(@ws.pivot_tables.last, pivot_table, "must be added to worksheet pivot tables collection")
+  end
+
+  def test_set_pivot_table_data_sheet
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5')
+    data_sheet = @ws.clone
+    data_sheet.name = "Pivot Table Data Source"
+
+    assert_equal(pivot_table.data_sheet.name, @ws.name, "must default to the same sheet the pivot table is added to")
+    pivot_table.data_sheet = data_sheet
+    assert_equal(pivot_table.data_sheet.name, data_sheet.name, "data sheet assigned to pivot table")
+  end
+
+  def test_add_pivot_table_with_config
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5') do |pt|
+      pt.rows = ['Year', 'Month']
+      pt.columns = ['Type']
+      pt.data = ['Sales']
+      pt.pages = ['Region']
+    end
+    assert_equal(['Year', 'Month'], pivot_table.rows)
+    assert_equal(['Type'], pivot_table.columns)
+    assert_equal([{:ref=>"Sales"}], pivot_table.data)
+    assert_equal(['Region'], pivot_table.pages)
+    shared_test_pivot_table_xml_validity(pivot_table)
+  end
+
+  def test_add_pivot_table_with_options_on_data_field
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5') do |pt|
+      pt.data = [{:ref=>"Sales", :subtotal => 'average'}]
+    end
+    assert_equal([{:ref=>"Sales", :subtotal => 'average'}], pivot_table.data)
+  end
+
+  def test_add_pivot_table_with_style_info
+    style_info_data = { :name=>"PivotStyleMedium9", :showRowHeaders=>"1", :showLastColumn=>"0"}
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5', {:style_info=>style_info_data}) do |pt|
+      pt.rows = ['Year', 'Month']
+      pt.columns = ['Type']
+      pt.data = ['Sales']
+      pt.pages = ['Region']
+    end
+    assert_equal(style_info_data, pivot_table.style_info)
+    shared_test_pivot_table_xml_validity(pivot_table)
+  end
+
+  def test_add_pivot_table_with_row_without_subtotals
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5', {:no_subtotals_on_headers=>['Year']}) do |pt|
+      pt.data = ['Sales']
+      pt.rows = ['Year','Month']
+    end
+    assert_equal(['Year'], pivot_table.no_subtotals_on_headers)
+  end
+
+ def test_header_indices
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5')
+    assert_equal(0,   pivot_table.header_index_of('Year'   ))
+    assert_equal(1,   pivot_table.header_index_of('Month'  ))
+    assert_equal(2,   pivot_table.header_index_of('Region' ))
+    assert_equal(3,   pivot_table.header_index_of('Type'   ))
+    assert_equal(4,   pivot_table.header_index_of('Sales'  ))
+    assert_equal(nil, pivot_table.header_index_of('Missing'))
+    assert_equal(%w(A1 B1 C1 D1 E1), pivot_table.header_cell_refs)
+  end
+
+  def test_pn
+    @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal(@ws.pivot_tables.first.pn, "pivotTables/pivotTable1.xml")
+  end
+
+  def test_index
+    @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal(@ws.pivot_tables.first.index, @ws.workbook.pivot_tables.index(@ws.pivot_tables.first))
+  end
+
+  def test_relationships
+    assert(@ws.relationships.empty?)
+    @ws.add_pivot_table('G5:G6', 'A1:D5')
+    assert_equal(@ws.relationships.size, 1, "adding a pivot table adds a relationship")
+    @ws.add_pivot_table('G10:G11', 'A1:D5')
+    assert_equal(@ws.relationships.size, 2, "adding a pivot table adds a relationship")
+  end
+
+  def test_to_xml_string
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5')
+    shared_test_pivot_table_xml_validity(pivot_table)
+  end
+
+  def test_to_xml_string_with_configuration
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5') do |pt|
+      pt.rows = ['Year', 'Month']
+      pt.columns = ['Type']
+      pt.data = ['Sales']
+      pt.pages = ['Region']
+    end
+    shared_test_pivot_table_xml_validity(pivot_table)
+  end
+
+  def test_to_xml_string_with_options_on_data_field
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5') do |pt|
+      pt.data = [{:ref=>"Sales", :subtotal => 'average'}]
+    end
+    shared_test_pivot_table_xml_validity(pivot_table)
+  end
+end