bonio-axlsx 2.2.1

data/test/workbook/tc_workbook_view.rb

@@ -0,0 +1,50 @@
+require 'tc_helper'
+
+class TestWorkbookView < Test::Unit::TestCase
+
+  def setup
+    @options = { visibility: :hidden, minimized: true, show_horizontal_scroll: true, show_vertical_scroll: true,
+                show_sheet_tabs: true, tab_ratio: 750, first_sheet: 0, active_tab: 1, x_window: 500, y_window: 400,
+                window_width: 800, window_height: 600, auto_filter_date_grouping: true }
+    @book_view = Axlsx::WorkbookView.new @options
+  end
+
+  def test_options_assignation
+    @options.each do |key, value|
+      assert_equal(value, @book_view.send(key))
+    end
+  end
+
+  def test_boolean_attribute_validation
+    %w(minimized show_horizontal_scroll show_vertical_scroll show_sheet_tabs auto_filter_date_grouping).each do |attr|
+      assert_raise(ArgumentError, 'only booleanish allowed in boolean attributes') { @book_view.send("#{attr}=", "banana") }
+      assert_nothing_raised { @book_view.send("#{attr}=", false )}
+    end
+  end
+
+  def test_integer_attribute_validation
+    %w(tab_ratio first_sheet active_tab x_window y_window window_width window_height).each do |attr|
+      assert_raise(ArgumentError, 'only integer allowed in integer attributes') { @book_view.send("#{attr}=", "b") }
+      assert_nothing_raised { @book_view.send("#{attr}=", 7 )}
+    end
+  end
+
+  def test_visibility_attribute_validation
+    assert_raise(ArgumentError) { @book_view.visibility = :foobar }
+    assert_nothing_raised { @book_view.visibility = :hidden }
+    assert_nothing_raised { @book_view.visibility = :very_hidden }
+    assert_nothing_raised { @book_view.visibility = :visible }
+  end
+
+  def test_to_xml_string
+    xml = @book_view.to_xml_string
+    doc = Nokogiri::XML(xml)
+    @options.each do |key, value|
+      if value == true || value == false
+        value = value ? 1 : 0
+      end
+      path = "workbookView[@#{Axlsx.camel(key, false)}='#{value}']"
+      assert_equal(1, doc.xpath(path).size)
+    end
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_auto_filter.rb

@@ -0,0 +1,38 @@
+require 'tc_helper.rb'
+
+class TestAutoFilter < Test::Unit::TestCase
+
+  def setup
+    ws = Axlsx::Package.new.workbook.add_worksheet
+    3.times { |index| ws.add_row [1*index,2*index,3*index] }
+    @auto_filter = ws.auto_filter
+    @auto_filter.range = 'A1:C3'
+    @auto_filter.add_column 0, :filters, :filter_items => [1]
+  end
+
+  def test_defined_name
+    assert_equal("'Sheet1'!$A$1:$C$3", @auto_filter.defined_name)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@auto_filter.to_xml_string)
+    assert(doc.xpath("autoFilter[@ref='#{@auto_filter.range}']"))
+  end
+
+  def test_columns
+    assert @auto_filter.columns.is_a?(Axlsx::SimpleTypedList)
+    assert_equal @auto_filter.columns.allowed_types, [Axlsx::FilterColumn]
+  end
+
+  def test_add_column
+    @auto_filter.add_column(0, :filters) do |column|
+      assert column.is_a? FilterColumn
+    end
+  end
+
+  def test_applya
+    assert_equal nil, @auto_filter.worksheet.rows.last.hidden
+    @auto_filter.apply
+    assert_equal true, @auto_filter.worksheet.rows.last.hidden
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filter_column.rb

@@ -0,0 +1,76 @@
+require 'tc_helper.rb'
+
+class TestFilterColumn < Test::Unit::TestCase
+
+  def setup
+    @filter_column = Axlsx::FilterColumn.new(0, :filters, :filter_items => [200])
+  end
+
+
+  def test_initialize_col_id
+    assert_raise ArgumentError do
+      Axlsx::FilterColumn.new(0, :bobs_house_of_filter)
+    end 
+    assert_raise ArgumentError do 
+      Axlsx::FilterColumn.new(:penut, :filters)
+    end 
+  end
+
+  def test_initailize_filter_type
+    assert @filter_column.filter.is_a?(Axlsx::Filters)
+    assert_equal 1, @filter_column.filter.filter_items.size
+  end
+
+  def test_initialize_filter_type_filters_with_options
+    assert_equal 200, @filter_column.filter.filter_items.first.val
+  end
+
+  def test_initialize_with_block
+    filter_column = Axlsx::FilterColumn.new(0, :filters) do |filters|
+      filters.filter_items = [700, 100, 5]
+    end
+    assert_equal 3, filter_column.filter.filter_items.size
+    assert_equal 700, filter_column.filter.filter_items.first.val
+    assert_equal 5, filter_column.filter.filter_items.last.val
+  end
+
+  def test_default_show_button
+    assert_equal true, @filter_column.show_button
+  end
+
+  def test_default_hidden_button
+    assert_equal false, @filter_column.hidden_button
+  end
+
+  def test_show_button
+    assert_raise ArgumentError do
+      @filter_column.show_button = :foo 
+    end
+    assert_nothing_raised { @filter_column.show_button = false }
+  end
+
+  def test_hidden_button
+    assert_raise ArgumentError do
+      @filter_column.hidden_button = :hoge
+    end 
+    assert_nothing_raised { @filter_column.hidden_button = true }
+  end
+
+  def test_col_id=
+    assert_raise ArgumentError do 
+    @filter_column.col_id = :bar
+    end 
+  assert_nothing_raised { @filter_column.col_id = 7 }
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filter_column.to_xml_string)
+    assert doc.xpath("//filterColumn[@colId=#{@filter_column.col_id}]")
+    assert doc.xpath("//filterColumn[@hiddenButton=#{@filter_column.hidden_button}]")
+    assert doc.xpath("//filterColumn[@showButton=#{@filter_column.show_button}]")
+
+
+
+    assert doc.xpath("//filterColumn/filters")
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filters.rb

@@ -0,0 +1,50 @@
+require 'tc_helper.rb'
+
+class TestFilters < Test::Unit::TestCase
+  def setup
+    @filters = Axlsx::Filters.new(:filter_items => [1, 'a'], 
+                                  :date_group_items =>[ { :date_time_grouping => :year, :year => 2011, :month => 11, :day => 11, :hour => 0, :minute => 0, :second => 0 } ] , 
+                                  :blank => true)
+  end
+
+  def test_blank
+    assert_equal true, @filters.blank
+    assert_raise(ArgumentError) { @filters.blank = :only_if_you_want_it }
+    @filters.blank = true
+    assert_equal true, @filters.blank
+  end
+
+  def test_calendar_type
+    assert_raise(ArgumentError) { @filters.calendar_type = 'monkey calendar' }
+    @filters.calendar_type = 'japan'
+    assert_equal('japan', @filters.calendar_type)
+  end
+
+  def test_filters_items
+    assert @filters.filter_items.is_a?(Array)
+    assert_equal 2, @filters.filter_items.size
+  end
+
+  def test_date_group_items
+    assert @filters.date_group_items.is_a?(Array)
+    assert_equal 1, @filters.date_group_items.size
+  end
+ 
+  def test_apply_is_false_for_matching_values
+    keeper = Object.new
+    def keeper.value; 'a'; end 
+    assert_equal false, @filters.apply(keeper)
+  end
+
+  def test_apply_is_true_for_non_matching_values
+    hidden = Object.new 
+    def hidden.value; 'b'; end
+    assert_equal true, @filters.apply(hidden)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filters.to_xml_string)
+    assert_equal(1, doc.xpath('//filters[@blank=1]').size)
+  end
+end
+

data/test/workbook/worksheet/tc_break.rb

@@ -0,0 +1,49 @@
+require 'tc_helper.rb'
+
+class TestBreak < Test::Unit::TestCase
+
+  def setup
+    @break = Axlsx::Break.new(:id => 1, :min => 1, :max => 10, :man => true, :pt => false)
+  end
+
+  def test_id
+    assert_equal(1, @break.id)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:hoge, {:id => -1})
+    end
+  end
+
+  def test_min
+    assert_equal(1, @break.min)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:hoge, :min => -1)
+    end
+  end
+
+  def test_max
+    assert_equal(10, @break.max)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:hoge, :max => -1)
+    end
+  end
+
+
+  def test_man
+    assert_equal(true, @break.man)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:man => -1)
+    end
+  end
+
+  def test_pt
+    assert_equal(false, @break.pt)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:pt => -1)
+    end
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@break.to_xml_string)
+    assert_equal(doc.xpath('//brk[@id="1"][@min="1"][@max="10"][@pt=0][@man=1]').size, 1)
+  end
+end

data/test/workbook/worksheet/tc_cell.rb

@@ -0,0 +1,373 @@
+require 'tc_helper.rb'
+
+class TestCell < Test::Unit::TestCase
+
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet :name=>"hmmm"
+    p.workbook.styles.add_style :sz=>20
+    @row = @ws.add_row
+    @c = @row.add_cell 1, :type=>:float, :style=>1
+    data = (0..26).map { |index| index }
+    @ws.add_row data
+    @cAA = @ws["AA2"]
+  end
+
+  def test_initialize
+    assert_equal(@row.cells.last, @c, "the cell was added to the row")
+    assert_equal(@c.type, :float, "type option is applied")
+    assert_equal(@c.style, 1, "style option is applied")
+    assert_equal(@c.value, 1.0, "type option is applied and value is casted")
+  end
+
+  def test_style_date_data
+    c = Axlsx::Cell.new(@c.row, Time.now)
+    assert_equal(Axlsx::STYLE_DATE, c.style)
+  end
+
+  def test_row
+    assert_equal(@c.row, @row)
+  end
+
+  def test_index
+    assert_equal(@c.index, @row.cells.index(@c))
+  end
+
+  def test_pos
+    assert_equal(@c.pos, [@c.index, @c.row.index(@c)])
+  end
+
+  def test_r
+    assert_equal(@c.r, "A1", "calculate cell reference")
+  end
+
+  def test_wide_r
+      assert_equal(@cAA.r, "AA2", "calculate cell reference")
+  end
+
+  def test_r_abs
+    assert_equal(@c.r_abs,"$A$1", "calculate absolute cell reference")
+    assert_equal(@cAA.r_abs,"$AA$2", "needs to accept multi-digit columns")
+  end
+
+  def test_name
+    @c.name = 'foo'
+    assert_equal(1, @ws.workbook.defined_names.size)
+    assert_equal('foo', @ws.workbook.defined_names.last.name)
+  end
+
+  def test_style
+    assert_raise(ArgumentError, "must reject invalid style indexes") { @c.style=@c.row.worksheet.workbook.styles.cellXfs.size }
+    assert_nothing_raised("must allow valid style index changes") {@c.style=1}
+    assert_equal(@c.style, 1)
+  end
+
+  def test_type
+    assert_raise(ArgumentError, "type must be :string, :integer, :float, :date, :time, :boolean") { @c.type = :array }
+    assert_nothing_raised("type can be changed") { @c.type = :string }
+    assert_equal(@c.value, "1.0", "changing type casts the value")
+    assert_equal(:float, @row.add_cell(1.0/10**7).type, 'properly identify exponential floats as float type')
+    assert_equal(@row.add_cell(Time.now).type, :time, 'time should be time')
+    assert_equal(@row.add_cell(Date.today).type, :date, 'date should be date')
+    assert_equal(@row.add_cell(true).type, :boolean, 'boolean should be boolean')
+  end
+
+  def test_value
+    assert_raise(ArgumentError, "type must be :string, :integer, :float, :date, :time, :boolean") { @c.type = :array }
+    assert_nothing_raised("type can be changed") { @c.type = :string }
+    assert_equal(@c.value, "1.0", "changing type casts the value")
+  end
+
+  def test_col_ref
+    #TODO move to axlsx spec
+    assert_equal(Axlsx.col_ref(0), "A")
+  end
+
+  def test_cell_type_from_value
+    assert_equal(@c.send(:cell_type_from_value, 1.0), :float)
+    assert_equal(@c.send(:cell_type_from_value, 1), :integer)
+    assert_equal(@c.send(:cell_type_from_value, Date.today), :date)
+    assert_equal(@c.send(:cell_type_from_value, Time.now), :time)
+    assert_equal(@c.send(:cell_type_from_value, []), :string)
+    assert_equal(@c.send(:cell_type_from_value, "d"), :string)
+    assert_equal(@c.send(:cell_type_from_value, nil), :string)
+    assert_equal(@c.send(:cell_type_from_value, -1), :integer)
+    assert_equal(@c.send(:cell_type_from_value, true), :boolean)
+    assert_equal(@c.send(:cell_type_from_value, false), :boolean)
+    assert_equal(@c.send(:cell_type_from_value, 1.0/10**6), :float)
+    assert_equal(@c.send(:cell_type_from_value, Axlsx::RichText.new), :richtext)
+    assert_equal(:iso_8601, @c.send(:cell_type_from_value, '2008-08-30T01:45:36.123+09:00'))
+  end
+
+  def test_cast_value
+    @c.type = :string
+    assert_equal(@c.send(:cast_value, 1.0), "1.0")
+    @c.type = :integer
+    assert_equal(@c.send(:cast_value, 1.0), 1)
+    @c.type = :float
+    assert_equal(@c.send(:cast_value, "1.0"), 1.0)
+    @c.type = :string
+    assert_equal(@c.send(:cast_value, nil), nil)
+    @c.type = :richtext
+    assert_equal(@c.send(:cast_value, nil), nil)
+    @c.type = :float
+    assert_equal(@c.send(:cast_value, nil), nil)
+    @c.type = :boolean
+    assert_equal(@c.send(:cast_value, true), 1)
+    assert_equal(@c.send(:cast_value, false), 0)
+    @c.type = :iso_8601
+    assert_equal("2012-10-10T12:24", @c.send(:cast_value, "2012-10-10T12:24"))
+  end
+
+  def test_cast_time_subclass
+    subtime = Class.new(Time) do
+      def to_time
+        raise "#to_time of Time subclass should not be called"
+      end
+    end
+
+    time = subtime.now
+
+    @c.type = :time
+    assert_equal(time, @c.send(:cast_value, time))
+  end
+
+  def test_color
+    assert_raise(ArgumentError) { @c.color = -1.1 }
+    assert_nothing_raised { @c.color = "FF00FF00" }
+    assert_equal(@c.color.rgb, "FF00FF00")
+  end
+
+  def test_scheme
+    assert_raise(ArgumentError) { @c.scheme = -1.1 }
+    assert_nothing_raised { @c.scheme = :major }
+    assert_equal(@c.scheme, :major)
+  end
+
+  def test_vertAlign
+    assert_raise(ArgumentError) { @c.vertAlign = -1.1 }
+    assert_nothing_raised { @c.vertAlign = :baseline }
+    assert_equal(@c.vertAlign, :baseline)
+  end
+
+  def test_sz
+    assert_raise(ArgumentError) { @c.sz = -1.1 }
+    assert_nothing_raised { @c.sz = 12 }
+    assert_equal(@c.sz, 12)
+  end
+
+  def test_extend
+    assert_raise(ArgumentError) { @c.extend = -1.1 }
+    assert_nothing_raised { @c.extend = false }
+    assert_equal(@c.extend, false)
+  end
+
+  def test_condense
+    assert_raise(ArgumentError) { @c.condense = -1.1 }
+    assert_nothing_raised { @c.condense = false }
+    assert_equal(@c.condense, false)
+  end
+
+  def test_shadow
+    assert_raise(ArgumentError) { @c.shadow = -1.1 }
+    assert_nothing_raised { @c.shadow = false }
+    assert_equal(@c.shadow, false)
+  end
+
+  def test_outline
+    assert_raise(ArgumentError) { @c.outline = -1.1 }
+    assert_nothing_raised { @c.outline = false }
+    assert_equal(@c.outline, false)
+  end
+
+  def test_strike
+    assert_raise(ArgumentError) { @c.strike = -1.1 }
+    assert_nothing_raised { @c.strike = false }
+    assert_equal(@c.strike, false)
+  end
+
+  def test_u
+    @c.type = :string
+    assert_raise(ArgumentError) { @c.u = -1.1 }
+    assert_nothing_raised { @c.u = :single }
+    assert_equal(@c.u, :single)
+    doc = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert(doc.xpath('//u[@val="single"]'))
+  end
+
+  def test_i
+    assert_raise(ArgumentError) { @c.i = -1.1 }
+    assert_nothing_raised { @c.i = false }
+    assert_equal(@c.i, false)
+  end
+
+  def test_rFont
+    assert_raise(ArgumentError) { @c.font_name = -1.1 }
+    assert_nothing_raised { @c.font_name = "Arial" }
+    assert_equal(@c.font_name, "Arial")
+  end
+
+  def test_charset
+    assert_raise(ArgumentError) { @c.charset = -1.1 }
+    assert_nothing_raised { @c.charset = 1 }
+    assert_equal(@c.charset, 1)
+  end
+
+  def test_family
+    assert_raise(ArgumentError) { @c.family = -1.1 }
+    assert_nothing_raised { @c.family = 5 }
+    assert_equal(@c.family, 5)
+  end
+
+  def test_b
+    assert_raise(ArgumentError) { @c.b = -1.1 }
+    assert_nothing_raised { @c.b = false }
+    assert_equal(@c.b, false)
+  end
+
+  def test_merge_with_string
+    @c.row.add_cell 2
+    @c.row.add_cell 3
+    @c.merge "A2"
+    assert_equal(@c.row.worksheet.send(:merged_cells).last, "A1:A2")
+  end
+
+  def test_merge_with_cell
+    @c.row.add_cell 2
+    @c.row.add_cell 3
+    @c.merge @row.cells.last
+    assert_equal(@c.row.worksheet.send(:merged_cells).last, "A1:C1")
+  end
+
+  def test_reverse_merge_with_cell
+    @c.row.add_cell 2
+    @c.row.add_cell 3
+    @row.cells.last.merge @c
+    assert_equal(@c.row.worksheet.send(:merged_cells).last, "A1:C1")
+  end
+
+  def test_ssti
+    assert_raise(ArgumentError, "ssti must be an unsigned integer!") { @c.send(:ssti=, -1) }
+    @c.send :ssti=, 1
+    assert_equal(@c.ssti, 1)
+  end
+
+  def test_plain_string
+    @c.type = :integer
+    assert_equal(@c.plain_string?, false)
+
+    @c.type = :string
+    @c.value = 'plain string'
+    assert_equal(@c.plain_string?, true)
+
+    @c.value = nil
+    assert_equal(@c.plain_string?, false)
+
+    @c.value = ''
+    assert_equal(@c.plain_string?, false)
+
+    @c.value = '=sum'
+    assert_equal(@c.plain_string?, false)
+
+    @c.value = 'plain string'
+    @c.font_name = 'Arial'
+    assert_equal(@c.plain_string?, false)
+  end
+
+  def test_to_xml_string
+    c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert_equal(c_xml.xpath("/c[@s=1]").size, 1)
+  end
+
+  def test_to_xml_string_nil
+    @c.value = nil
+    c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert_equal(c_xml.xpath("/c[@s=1]").size, 1)
+  end
+
+  def test_to_xml_string_with_run
+    # Actually quite a number of similar run styles
+    # but the processing should be the same
+    @c.b = true
+    @c.type = :string
+    @c.value = "a"
+    @c.font_name = 'arial'
+    @c.color = 'FF0000'
+    c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert(c_xml.xpath("//b").any?)
+  end
+
+  def test_to_xml_string_formula
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet do |sheet|
+      sheet.add_row ["=IF(2+2=4,4,5)"]
+    end
+    doc = Nokogiri::XML(ws.to_xml_string)
+    doc.remove_namespaces!
+    assert(doc.xpath("//f[text()='IF(2+2=4,4,5)']").any?)
+  end
+
+  def test_to_xml_string_array_formula
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet do |sheet|
+      sheet.add_row ["{=SUM(C2:C11*D2:D11)}"]
+    end
+    doc = Nokogiri::XML(ws.to_xml_string)
+    doc.remove_namespaces!
+    assert(doc.xpath("//f[text()='SUM(C2:C11*D2:D11)']").any?)
+    assert(doc.xpath("//f[@t='array']").any?)
+    assert(doc.xpath("//f[@ref='A1']").any?)
+  end
+
+  def test_to_xml_string_text_formula
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet do |sheet|
+      sheet.add_row ["=1+1", "-1+1"], type: :text
+    end
+    doc = Nokogiri::XML(ws.to_xml_string)
+    doc.remove_namespaces!
+
+    assert(doc.xpath("//f[text()='1+1']").empty?)
+    assert(doc.xpath("//t[text()='=1+1']").any?)
+
+    assert(doc.xpath("//f[text()='1+1']").empty?)
+    assert(doc.xpath("//t[text()='-1+1']").any?)
+  end
+
+  def test_font_size_with_custom_style_and_no_sz
+    @c.style = @c.row.worksheet.workbook.styles.add_style :bg_color => 'FF00FF'
+    sz = @c.send(:font_size)
+    assert_equal(sz, @c.row.worksheet.workbook.styles.fonts.first.sz)
+  end
+
+  def test_font_size_with_bolding
+    @c.style = @c.row.worksheet.workbook.styles.add_style :b => true
+    assert_equal(@c.row.worksheet.workbook.styles.fonts.first.sz * 1.5, @c.send(:font_size))
+  end
+
+  def test_font_size_with_custom_sz
+    @c.style = @c.row.worksheet.workbook.styles.add_style :sz => 52
+    sz = @c.send(:font_size)
+    assert_equal(sz, 52)
+  end
+
+  def test_cell_with_sz
+    @c.sz = 25
+    assert_equal(25, @c.send(:font_size))
+  end
+
+  def test_to_xml
+    # TODO This could use some much more stringent testing related to the xml content generated!
+    @ws.add_row [Time.now, Date.today, true, 1, 1.0, "text", "=sum(A1:A2)", "2013-01-13T13:31:25.123"]
+    @ws.rows.last.cells[5].u = true
+
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+end