bonio-axlsx 2.2.1

data/test/stylesheet/tc_border.rb

@@ -0,0 +1,37 @@
+require 'tc_helper.rb'
+
+class TestBorder < Test::Unit::TestCase
+  def setup
+    @b = Axlsx::Border.new
+  end
+  def teardown
+  end
+  def test_initialiation
+    assert_equal(@b.diagonalUp, nil)
+    assert_equal(@b.diagonalDown, nil)
+    assert_equal(@b.outline, nil)
+    assert(@b.prs.is_a?(Axlsx::SimpleTypedList))
+  end
+
+  def test_diagonalUp
+    assert_raise(ArgumentError) { @b.diagonalUp = :red }
+    assert_nothing_raised { @b.diagonalUp = true }
+    assert_equal(@b.diagonalUp, true )
+  end
+
+  def test_diagonalDown
+    assert_raise(ArgumentError) { @b.diagonalDown = :red }
+    assert_nothing_raised { @b.diagonalDown = true }
+    assert_equal(@b.diagonalDown, true )
+  end
+
+  def test_outline
+    assert_raise(ArgumentError) { @b.outline = :red }
+    assert_nothing_raised { @b.outline = true }
+    assert_equal(@b.outline, true )
+  end
+
+  def test_prs
+    assert_nothing_raised { @b.prs << Axlsx::BorderPr.new(:name=>:top, :style=>:thin, :color => Axlsx::Color.new(:rgb=>"FF0000FF")) }
+  end
+end

data/test/stylesheet/tc_border_pr.rb

@@ -0,0 +1,32 @@
+require 'tc_helper.rb'
+
+class TestBorderPr < Test::Unit::TestCase
+  def setup
+    @bpr = Axlsx::BorderPr.new
+  end
+  def teardown
+  end
+  def test_initialiation
+    assert_equal(@bpr.color, nil)
+    assert_equal(@bpr.style, nil)
+    assert_equal(@bpr.name, nil)
+  end
+
+  def test_color
+    assert_raise(ArgumentError) { @bpr.color = :red }
+    assert_nothing_raised { @bpr.color = Axlsx::Color.new :rgb=>"FF000000" }
+    assert(@bpr.color.is_a?(Axlsx::Color))
+  end
+
+  def test_style
+    assert_raise(ArgumentError) { @bpr.style = :red }
+    assert_nothing_raised { @bpr.style = :thin }
+    assert_equal(@bpr.style, :thin)
+  end
+
+  def test_name
+    assert_raise(ArgumentError) { @bpr.name = :red }
+    assert_nothing_raised { @bpr.name = :top }
+    assert_equal(@bpr.name, :top)
+  end
+end

data/test/stylesheet/tc_cell_alignment.rb

@@ -0,0 +1,81 @@
+require 'tc_helper.rb'
+
+class TestCellAlignment < Test::Unit::TestCase
+  def setup
+    @item = Axlsx::CellAlignment.new
+  end
+
+  def test_initialiation
+    assert_equal(@item.horizontal, nil)
+    assert_equal(@item.vertical, nil)
+    assert_equal(@item.textRotation, nil)
+    assert_equal(@item.wrapText, nil)
+    assert_equal(@item.indent, nil)
+    assert_equal(@item.relativeIndent, nil)
+    assert_equal(@item.justifyLastLine, nil)
+    assert_equal(@item.shrinkToFit, nil)
+    assert_equal(@item.readingOrder, nil)
+    options =  { :horizontal => :left, :vertical => :top, :textRotation => 3,
+                 :wrapText => true, :indent => 2, :relativeIndent => 5,
+      :justifyLastLine => true, :shrinkToFit => true, :readingOrder => 2 }
+    ca = Axlsx::CellAlignment.new options
+    options.each do |key, value|
+      assert_equal(ca.send(key.to_sym),value)
+    end
+  end
+
+  def test_horizontal
+    assert_raise(ArgumentError) { @item.horizontal = :red }
+    assert_nothing_raised { @item.horizontal = :left }
+    assert_equal(@item.horizontal, :left )
+  end
+
+  def test_vertical
+    assert_raise(ArgumentError) { @item.vertical = :red }
+    assert_nothing_raised { @item.vertical = :top }
+    assert_equal(@item.vertical, :top )
+  end
+
+  def test_textRotation
+    assert_raise(ArgumentError) { @item.textRotation = -1 }
+    assert_nothing_raised { @item.textRotation = 5 }
+    assert_equal(@item.textRotation, 5 )
+  end
+
+  def test_wrapText
+    assert_raise(ArgumentError) { @item.wrapText = -1 }
+    assert_nothing_raised { @item.wrapText = false }
+    assert_equal(@item.wrapText, false )
+  end
+
+  def test_indent
+    assert_raise(ArgumentError) { @item.indent = -1 }
+    assert_nothing_raised { @item.indent = 5 }
+    assert_equal(@item.indent, 5 )
+  end
+
+  def test_relativeIndent
+    assert_raise(ArgumentError) { @item.relativeIndent = :symbol }
+    assert_nothing_raised { @item.relativeIndent = 5 }
+    assert_equal(@item.relativeIndent, 5 )
+  end
+
+  def test_justifyLastLine
+    assert_raise(ArgumentError) { @item.justifyLastLine = -1 }
+    assert_nothing_raised { @item.justifyLastLine = true }
+    assert_equal(@item.justifyLastLine, true )
+  end
+
+  def test_shrinkToFit
+    assert_raise(ArgumentError) { @item.shrinkToFit = -1 }
+    assert_nothing_raised { @item.shrinkToFit = true }
+    assert_equal(@item.shrinkToFit, true )
+  end
+
+  def test_readingOrder
+    assert_raise(ArgumentError) { @item.readingOrder = -1 }
+    assert_nothing_raised { @item.readingOrder = 2 }
+    assert_equal(@item.readingOrder, 2 )
+  end
+
+end

data/test/stylesheet/tc_cell_protection.rb

@@ -0,0 +1,29 @@
+require 'tc_helper.rb'
+
+class TestCellProtection < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::CellProtection.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.hidden, nil)
+    assert_equal(@item.locked, nil)
+  end
+
+  def test_hidden
+    assert_raise(ArgumentError) { @item.hidden = -1 }
+    assert_nothing_raised { @item.hidden = false }
+    assert_equal(@item.hidden, false )
+  end
+
+  def test_locked
+    assert_raise(ArgumentError) { @item.locked = -1 }
+    assert_nothing_raised { @item.locked = false }
+    assert_equal(@item.locked, false )
+  end
+
+end

data/test/stylesheet/tc_cell_style.rb

@@ -0,0 +1,57 @@
+require 'tc_helper.rb'
+
+class TestCellStyle < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::CellStyle.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.name, nil)
+    assert_equal(@item.xfId, nil)
+    assert_equal(@item.builtinId, nil)
+    assert_equal(@item.iLevel, nil)
+    assert_equal(@item.hidden, nil)
+    assert_equal(@item.customBuiltin, nil)
+  end
+
+  def test_name
+    assert_raise(ArgumentError) { @item.name = -1 }
+    assert_nothing_raised { @item.name = "stylin" }
+    assert_equal(@item.name, "stylin" )
+  end
+
+  def test_xfId
+    assert_raise(ArgumentError) { @item.xfId = -1 }
+    assert_nothing_raised { @item.xfId = 5 }
+    assert_equal(@item.xfId, 5 )
+  end
+
+  def test_builtinId
+    assert_raise(ArgumentError) { @item.builtinId = -1 }
+    assert_nothing_raised { @item.builtinId = 5 }
+    assert_equal(@item.builtinId, 5 )
+  end
+
+  def test_iLevel
+    assert_raise(ArgumentError) { @item.iLevel = -1 }
+    assert_nothing_raised { @item.iLevel = 5 }
+    assert_equal(@item.iLevel, 5 )
+  end
+
+  def test_hidden
+    assert_raise(ArgumentError) { @item.hidden = -1 }
+    assert_nothing_raised { @item.hidden = true }
+    assert_equal(@item.hidden, true )
+  end
+
+  def test_customBuiltin
+    assert_raise(ArgumentError) { @item.customBuiltin = -1 }
+    assert_nothing_raised { @item.customBuiltin = true }
+    assert_equal(@item.customBuiltin, true )
+  end
+
+end

data/test/stylesheet/tc_color.rb

@@ -0,0 +1,43 @@
+require 'tc_helper.rb'
+
+class TestColor < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Color.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.auto, nil)
+    assert_equal(@item.rgb, "FF000000")
+    assert_equal(@item.tint, nil)
+  end
+
+  def test_auto
+    assert_raise(ArgumentError) { @item.auto = -1 }
+    assert_nothing_raised { @item.auto = true }
+    assert_equal(@item.auto, true )
+  end
+
+  def test_rgb
+    assert_raise(ArgumentError) { @item.rgb = -1 }
+    assert_nothing_raised { @item.rgb = "FF00FF00" }
+    assert_equal(@item.rgb, "FF00FF00" )
+  end
+
+  def test_rgb_writer_doesnt_mutate_its_argument
+    my_rgb = 'ff00ff00'
+    @item.rgb = my_rgb
+    assert_equal 'ff00ff00', my_rgb
+  end
+
+  def test_tint
+    assert_raise(ArgumentError) { @item.tint = -1 }
+    assert_nothing_raised { @item.tint = -1.0 }
+    assert_equal(@item.tint, -1.0 )
+  end
+
+
+end

data/test/stylesheet/tc_dxf.rb

@@ -0,0 +1,81 @@
+require 'tc_helper.rb'
+
+class TestDxf < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Dxf.new
+    @styles = Axlsx::Styles.new    
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.alignment, nil)
+    assert_equal(@item.protection, nil)
+    assert_equal(@item.numFmt, nil)
+    assert_equal(@item.font, nil)
+    assert_equal(@item.fill, nil)
+    assert_equal(@item.border, nil)
+  end
+
+  def test_alignment
+    assert_raise(ArgumentError) { @item.alignment = -1.1 }
+    assert_nothing_raised { @item.alignment = Axlsx::CellAlignment.new }
+    assert(@item.alignment.is_a?(Axlsx::CellAlignment))
+  end
+
+  def test_protection
+    assert_raise(ArgumentError) { @item.protection = -1.1 }
+    assert_nothing_raised { @item.protection = Axlsx::CellProtection.new }
+    assert(@item.protection.is_a?(Axlsx::CellProtection))
+  end
+
+  def test_numFmt
+    assert_raise(ArgumentError) { @item.numFmt = 1 }
+    assert_nothing_raised { @item.numFmt = Axlsx::NumFmt.new }
+    assert @item.numFmt.is_a? Axlsx::NumFmt
+  end
+
+  def test_fill
+    assert_raise(ArgumentError) { @item.fill =  1 }
+    assert_nothing_raised { @item.fill = Axlsx::Fill.new(Axlsx::PatternFill.new(:patternType =>:solid, :fgColor=> Axlsx::Color.new(:rgb => "FF000000"))) }
+    assert @item.fill.is_a? Axlsx::Fill
+  end
+
+  def test_font
+    assert_raise(ArgumentError) { @item.font = 1 }
+    assert_nothing_raised { @item.font = Axlsx::Font.new }
+    assert @item.font.is_a? Axlsx::Font 
+  end
+
+  def test_border
+    assert_raise(ArgumentError) { @item.border = 1 }
+    assert_nothing_raised { @item.border = Axlsx::Border.new }
+    assert @item.border.is_a? Axlsx::Border
+  end
+
+  def test_to_xml
+    @item.border = Axlsx::Border.new
+    doc = Nokogiri::XML.parse(@item.to_xml_string)
+    assert_equal(1, doc.xpath(".//dxf//border").size)
+    assert_equal(0, doc.xpath(".//dxf//font").size)    
+  end
+
+  def test_many_options_xml
+    @item.border = Axlsx::Border.new
+    @item.alignment = Axlsx::CellAlignment.new
+    @item.fill = Axlsx::Fill.new(Axlsx::PatternFill.new(:patternType =>:solid, :fgColor=> Axlsx::Color.new(:rgb => "FF000000")))
+    @item.font = Axlsx::Font.new
+    @item.protection = Axlsx::CellProtection.new
+    @item.numFmt = Axlsx::NumFmt.new
+    
+    doc = Nokogiri::XML.parse(@item.to_xml_string)
+    assert_equal(1, doc.xpath(".//dxf//fill//patternFill[@patternType='solid']//fgColor[@rgb='FF000000']").size)
+    assert_equal(1, doc.xpath(".//dxf//font").size)
+    assert_equal(1, doc.xpath(".//dxf//protection").size)
+    assert_equal(1, doc.xpath(".//dxf//numFmt[@numFmtId='0'][@formatCode='']").size)
+    assert_equal(1, doc.xpath(".//dxf//alignment").size)
+    assert_equal(1, doc.xpath(".//dxf//border").size)    
+  end
+end

data/test/stylesheet/tc_fill.rb

@@ -0,0 +1,18 @@
+require 'tc_helper.rb'
+
+class TestFill < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Fill.new Axlsx::PatternFill.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert(@item.fill_type.is_a?(Axlsx::PatternFill))
+    assert_raise(ArgumentError) { Axlsx::Fill.new }
+    assert_nothing_raised { Axlsx::Fill.new(Axlsx::GradientFill.new) }
+  end
+
+end

data/test/stylesheet/tc_font.rb

@@ -0,0 +1,121 @@
+require 'tc_helper.rb'
+
+class TestFont < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Font.new
+  end
+
+  def teardown
+  end
+
+
+  def test_initialiation
+    assert_equal(@item.name, nil)
+    assert_equal(@item.charset, nil)
+    assert_equal(@item.family, nil)
+    assert_equal(@item.b, nil)
+    assert_equal(@item.i, nil)
+    assert_equal(@item.u, nil)
+    assert_equal(@item.strike, nil)
+    assert_equal(@item.outline, nil)
+    assert_equal(@item.shadow, nil)
+    assert_equal(@item.condense, nil)
+    assert_equal(@item.extend, nil)
+    assert_equal(@item.color, nil)
+    assert_equal(@item.sz, nil)
+  end
+
+
+
+    # def name=(v) Axlsx::validate_string v; @name = v end
+  def test_name
+    assert_raise(ArgumentError) { @item.name = 7 }
+    assert_nothing_raised { @item.name = "bob" }
+    assert_equal(@item.name, "bob")
+  end
+    # def charset=(v) Axlsx::validate_unsigned_int v; @charset = v end
+  def test_charset
+    assert_raise(ArgumentError) { @item.charset = -7 }
+    assert_nothing_raised { @item.charset = 5 }
+    assert_equal(@item.charset, 5)
+  end
+
+    # def family=(v) Axlsx::validate_unsigned_int v; @family = v end
+  def test_family
+    assert_raise(ArgumentError) { @item.family = -7 }
+    assert_nothing_raised { @item.family = 5 }
+    assert_equal(@item.family, 5)
+  end
+
+    # def b=(v) Axlsx::validate_boolean v; @b = v end
+  def test_b
+    assert_raise(ArgumentError) { @item.b = -7 }
+    assert_nothing_raised { @item.b = true }
+    assert_equal(@item.b, true)
+  end
+
+    # def i=(v) Axlsx::validate_boolean v; @i = v end
+  def test_i
+    assert_raise(ArgumentError) { @item.i = -7 }
+    assert_nothing_raised { @item.i = true }
+    assert_equal(@item.i, true)
+  end
+
+    # def u=(v) Axlsx::validate_boolean v; @u = v end
+  def test_u
+    assert_raise(ArgumentError) { @item.u = -7 }
+    assert_nothing_raised { @item.u = true }
+    assert_equal(@item.u, true)
+  end
+
+    # def strike=(v) Axlsx::validate_boolean v; @strike = v end
+  def test_strike
+    assert_raise(ArgumentError) { @item.strike = -7 }
+    assert_nothing_raised { @item.strike = true }
+    assert_equal(@item.strike, true)
+  end
+
+    # def outline=(v) Axlsx::validate_boolean v; @outline = v end
+  def test_outline
+    assert_raise(ArgumentError) { @item.outline = -7 }
+    assert_nothing_raised { @item.outline = true }
+    assert_equal(@item.outline, true)
+  end
+
+    # def shadow=(v) Axlsx::validate_boolean v; @shadow = v end
+  def test_shadow
+    assert_raise(ArgumentError) { @item.shadow = -7 }
+    assert_nothing_raised { @item.shadow = true }
+    assert_equal(@item.shadow, true)
+  end
+
+    # def condense=(v) Axlsx::validate_boolean v; @condense = v end
+  def test_condense
+    assert_raise(ArgumentError) { @item.condense = -7 }
+    assert_nothing_raised { @item.condense = true }
+    assert_equal(@item.condense, true)
+  end
+
+    # def extend=(v) Axlsx::validate_boolean v; @extend = v end
+  def test_extend
+    assert_raise(ArgumentError) { @item.extend = -7 }
+    assert_nothing_raised { @item.extend = true }
+    assert_equal(@item.extend, true)
+  end
+
+    # def color=(v) DataTypeValidator.validate "Font.color", Color, v; @color=v end
+  def test_color
+    assert_raise(ArgumentError) { @item.color = -7 }
+    assert_nothing_raised { @item.color = Axlsx::Color.new(:rgb=>"00000000") }
+    assert(@item.color.is_a?(Axlsx::Color))
+  end
+
+    # def sz=(v) Axlsx::validate_unsigned_int v; @sz=v end
+  def test_sz
+    assert_raise(ArgumentError) { @item.sz = -7 }
+    assert_nothing_raised { @item.sz = 5 }
+    assert_equal(@item.sz, 5)
+  end
+
+end