axlsx 1.0.0

data/test/stylesheet/tc_xf.rb~

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestXf < Test::Unit::TestCase
+
+  def setup
+    @item = Axlsx::Xf.new
+  end
+
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.defaultTableStyle, "TableStyleMedium9")
+    assert_equal(@item.defaultPivotStyle, "PivotStyleLight16")
+  end
+
+  def test_defaultTableStyle    
+    assert_raise(ArgumentError) { @item.defaultTableStyle = -1.1 }
+    assert_nothing_raised { @item.defaultTableStyle = "anyones guess" }
+    assert_equal(@item.defaultTableStyle, "anyones guess")
+  end
+
+  def test_defaultPivotStyle    
+    assert_raise(ArgumentError) { @item.defaultPivotStyle = -1.1 }
+    assert_nothing_raised { @item.defaultPivotStyle = "anyones guess" }
+    assert_equal(@item.defaultPivotStyle, "anyones guess")
+  end
+
+end

data/test/tc_app.rb~

@@ -0,0 +1,19 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestApp < Test::Unit::TestCase
+  def setup    
+  end
+  def teardown
+  end
+  
+  def test_valid_document
+    schema = Nokogiri::XML::Schema(File.open("schema/shared-documentPropertiesExtended.xsd"))
+    doc = Nokogiri::XML(Axlsx::App.new.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors << error
+    end
+    assert_equal(errors.size, 0, "app.xml invalid" + errors.map{ |e| e.message }.to_s)
+  end
+end

data/test/tc_border_pr.rb~

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestBorderPr < Test::Unit::TestCase
+  def setup    
+    @bpr = Axlsx::BorderPr.new
+  end
+  def teardown
+  end
+  
+  def test_valid_document
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@styles.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.size == 0)
+  end
+

data/test/tc_package.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestPackage < Test::Unit::TestCase
+  def setup    
+    @package = Axlsx::Package.new
+    ws = @package.workbook.add_worksheet
+    chart = ws.add_chart Axlsx::Pie3DChart
+    chart.add_series :data=>[1,2,3], :labels=>["a", "b", "c"]
+  end
+
+  def test_default_objects_are_created
+    assert(@package.instance_values["app"].is_a?(Axlsx::App), 'App object not created')
+    assert(@package.instance_values["core"].is_a?(Axlsx::Core), 'Core object not created')
+    assert(@package.workbook.is_a?(Axlsx::Workbook), 'Workbook object not created')
+    assert(Axlsx::Package.new.workbook.worksheets.size == 0, 'Workbook should not have sheets by default')
+  end
+
+  def test_serialization
+    fname = 'test_serialization.xlsx'
+    assert_nothing_raised do
+      if File.writable? fname
+        f = File.open(fname, 'w')      
+        z= @package.serialize(f)      
+        
+        zf = Zip::ZipFile.open(f.path)
+        @package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
+        File.delete(f.path)
+        
+      else
+        puts "Skipping serialization to disk as write permission is not granted to this use in this directory"
+      end
+    end
+    
+  end
+  
+  def test_validation
+    assert_equal(@package.validate.size, 0, @package.validate)
+    #how to test for failure? the internal validations on the models are so strict I cant break anthing.....
+  end
+
+  def test_parts
+    p = @package.send(:parts)
+    p.each do |part|
+      #all parts must have :doc, :entry, :schema
+      assert(part.keys.size == 3 && part.keys.reject{ |k| [:doc, :entry, :schema].include? k}.empty?) 
+    end
+    #all parts have an entry
+    assert_equal(p.select{ |part| part[:entry] =~ /_rels\/\.rels/ }.size, 1, "rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /docProps\/core\.xml/ }.size, 1, "core missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /docProps\/app\.xml/ }.size, 1, "app missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/_rels\/workbook\.xml\.rels/ }.size, 1, "workbook rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/workbook\.xml/ }.size, 1, "workbook missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /\[Content_Types\]\.xml/ }.size, 1, "content types missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/styles\.xml/ }.size, 1, "styles missin")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/drawings\/_rels\/drawing\d\.xml\.rels/ }.size, @package.workbook.drawings.size, "one or more drawing rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/drawings\/drawing\d\.xml/ }.size, @package.workbook.drawings.size, "one or more drawings missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/charts\/chart\d\.xml/ }.size, @package.workbook.charts.size, "one or more charts missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/sheet\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/_rels\/sheet\d\.xml\.rels/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+
+    #no mystery parts
+    assert_equal(p.size, 12)
+
+  end
+  
+  def test_workbook_is_a_workbook
+    assert @package.workbook.is_a? Axlsx::Workbook
+  end
+end

data/test/tc_package.rb~

@@ -0,0 +1,64 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestPackage < Test::Unit::TestCase
+  def setup    
+    @package = Axlsx::Package.new
+    ws = @package.workbook.add_worksheet
+    chart = ws.add_chart Axlsx::Pie3DChart
+    chart.add_series :data=>[1,2,3], :labels=>["a", "b", "c"]
+  end
+
+  def test_default_objects_are_created
+    assert(@package.instance_values["app"].is_a?(Axlsx::App), 'App object not created')
+    assert(@package.instance_values["core"].is_a?(Axlsx::Core), 'Core object not created')
+    assert(@package.workbook.is_a?(Axlsx::Workbook), 'Workbook object not created')
+    assert(Axlsx::Package.new.workbook.worksheets.size == 0, 'Workbook should not have sheets by default')
+  end
+
+  def test_serialization
+    fname = 'test_serialization.xlsx'
+    assert_nothing_raised do
+      f = File.open(fname, 'w')      
+      z= @package.serialize(f)      
+      
+      zf = Zip::ZipFile.open(f.path)
+      @package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
+      File.delete(f.path)
+    end
+  end
+  
+  def test_validation
+    assert_equal(@package.validate.size, 0, @package.validate)
+    #how to test for failure? the internal validations on the models are so strict I cant break anthing.....
+  end
+
+  def test_parts
+    p = @package.send(:parts)
+    p.each do |part|
+      #all parts must have :doc, :entry, :schema
+      assert(part.keys.size == 3 && part.keys.reject{ |k| [:doc, :entry, :schema].include? k}.empty?) 
+    end
+    #all parts have an entry
+    assert_equal(p.select{ |part| part[:entry] =~ /_rels\/\.rels/ }.size, 1, "rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /docProps\/core\.xml/ }.size, 1, "core missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /docProps\/app\.xml/ }.size, 1, "app missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/_rels\/workbook\.xml\.rels/ }.size, 1, "workbook rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/workbook\.xml/ }.size, 1, "workbook missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /\[Content_Types\]\.xml/ }.size, 1, "content types missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/styles\.xml/ }.size, 1, "styles missin")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/drawings\/_rels\/drawing\d\.xml\.rels/ }.size, @package.workbook.drawings.size, "one or more drawing rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/drawings\/drawing\d\.xml/ }.size, @package.workbook.drawings.size, "one or more drawings missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/charts\/chart\d\.xml/ }.size, @package.workbook.charts.size, "one or more charts missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/sheet\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/_rels\/sheet\d\.xml\.rels/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+
+    #no mystery parts
+    assert_equal(p.size, 12)
+
+  end
+  
+  def test_workbook_is_a_workbook
+    assert @package.workbook.is_a? Axlsx::Workbook
+  end
+end

data/test/tc_pie_3D_chart.rb~

@@ -0,0 +1,66 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestPie3DChart < Test::Unit::TestCase
+
+  def setup
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet
+    @row = ws.add_row :values=>["one", 1, Time.now]
+    @chart = ws.drawing.add_chart Axlsx::Pie3DChart, :title => "fishery"
+  end
+
+  def teardown
+  end
+
+  def test_initialization
+    assert_equal(@chart.workbook.charts.last,@chart, "the chart is in the workbook")
+    assert_equal(@chart.title.text, "fishery", "the title option has been applied")
+    assert((@chart.series.is_a?(Axlsx::SimpleTypedList) && @chart.series.empty?), "The series is initialized and empty") 
+  end
+
+  def test_title
+    @chart.title.text = 'wowzer'
+    assert_equal(@chart.title.text, "wowzer", "the title text via a string")
+    assert_equal(@chart.title.cell, nil, "the title cell is nil as we set the title with text.")
+    @chart.title.cell = @row.cells.first
+    assert_equal(@chart.title.text, "one", "the title text was set via cell reference")
+    assert_equal(@chart.title.cell, @row.cells.first)
+  end
+
+  def test_add_series    
+    s = @chart.add_series :data=>[0,1,2,3], :labels => ["one", 1, "anything"], :title=>"bob"
+    assert_equal(@chart.series.last, s, "series has been added to chart series collection")
+    assert_equal(s.title, "bob", "series title has been applied")
+    assert_equal(s.data, [0,1,2,3], "data option applied")
+    assert_equal(s.labels, ["one",1,"anything"], "labels option applied")    
+  end  
+  
+  def test_create_range
+    
+  end
+
+  def test_pn
+    assert_equal(@chart.pn, "charts/chart1.xml")
+  end
+
+  def test_rId
+    assert_equal(@chart.rId, "rId1")
+  end
+  
+  def test_index
+    assert_equal(@chart.index, @chart.workbook.charts.index(@chart))
+  end
+
+  def test_to_xml
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::DRAWING_XSD))
+    doc = Nokogiri::XML(@chart.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end  
+  
+end

data/test/tc_relationships.rb~

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestRelationships < Test::Unit::TestCase
+  def setup    
+    @rels = Axlsx::Relationships.new
+  end
+  
+  def teardown    
+  end  
+
+  def test_valid_document
+    schema = Nokogiri::XML::Schema(File.open("schema/opc-relationships.xsd"))
+    doc = Nokogiri::XML(@rels.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      puts error.message
+      errors << error
+    end
+
+    @rels << Axlsx::Relationship.new(Axlsx::WORKSHEET_R, "bar")
+    doc = Nokogiri::XML(@rels.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      puts error.message
+      errors << error
+    end
+
+    assert(errors.size == 0)    
+  end
+
+  def test_require_valid_relationship_type
+    assert_raise(ArgumentError) { Axlsx::Relationship.new("Unknown", "bar" ) }    
+    assert_nothing_raised { Axlsx::Relationship.new(Axlsx::CHART_R, "bar") }    
+  end
+
+end

data/test/tc_series.rb~

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestSeries < Test::Unit::TestCase
+
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet :name=>"hmmm"
+    chart = @ws.drawing.add_chart Axlsx::Pie3DChart, :title => "fishery"
+    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob"
+  end
+  
+  def test_initialize
+    assert_equal(@series.title, "bob", "series title has been applied")
+    assert_equal(@series.data, [0,1,2], "data option applied")
+    assert_equal(@series.labels, ["zero", "one","two"], "labels option applied")    
+  end
+
+  def test_range
+    labels = @ws.add_row :values=>["one", "two", "three"]
+    data = @ws.add_row :values=>[1,2,3]
+    s = @series.chart.add_series :data=>data.cells, :labels=>labels.cells
+    assert_equal(s.send(:range, s.data), "#{@ws.name}!$A$2:$C$2", "range is created created from cells")
+    assert_equal(s.send(:range, s.labels), "#{@ws.name}!$A$1:$C$1", "range is created from cells")
+    assert_equal(@series.send(:range, @series.data), "", "no range if the data is a simple array")
+  end
+  
+  def test_index
+    assert_equal(@series.index, @series.chart.series.index(@series))
+  end
+end

data/test/tc_styles.rb~

@@ -0,0 +1,64 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestStyles < Test::Unit::TestCase
+  def setup    
+    @styles = Axlsx::Styles.new
+  end
+  def teardown
+  end
+  
+  def test_valid_document
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@styles.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.size == 0)
+  end
+
+
+  def test_add_style
+    fill_count = @styles.fills.size
+    font_count = @styles.fonts.size
+    xf_count = @styles.cellXfs.size
+
+    @styles.add_style :bg_color=>"FF000000", :fg_color=>"FFFFFFFF", :sz=>13, :numFmt=>Axlsx::NUM_FMT_PERCENT, :alignment=>{:horizontal=>:left}, :borderId=>Axlsx::BORDER_ID_ALL, :hidden=>true, :locked=>true
+    assert_equal(@styles.fills.size, fill_count+1)
+    assert_equal(@styles.fonts.size, font_count+1)
+    assert_equal(@styles.cellXfs.size, xf_count+1)
+    xf = @styles.cellXfs.last
+    assert_equal(xf.fillId, (@styles.fills.size-1), "points to the last created fill")
+    assert_equal(@styles.fills.last.fill_type.fgColor.rgb, "FF000000", "fill created with color")
+
+    assert_equal(xf.fontId, (@styles.fonts.size-1), "points to the last created font")
+    assert_equal(@styles.fonts.last.sz, 13, "font sz applied")
+    assert_equal(@styles.fonts.last.color.rgb, "FFFFFFFF", "font color applied")
+
+    assert_equal(xf.borderId, Axlsx::BORDER_ID_ALL, "border id is set")
+    assert_equal(xf.numFmtId, Axlsx::NUM_FMT_PERCENT, "number format id is set")
+
+    assert(xf.alignment.is_a?(Axlsx::CellAlignment), "alignment was created")
+    assert_equal(xf.alignment.horizontal, :left, "horizontal alignment applied")
+    assert_equal(xf.applyProtection, 1, "protection applied")
+    assert_equal(xf.protection.hidden, true, "hidden protection set")
+    assert_equal(xf.protection.locked, true, "cell locking set")
+    assert_raise(ArgumentError, "should reject invalid borderId") { @styles.add_style :borderId => 2 }
+
+  end
+
+
+  #:numFmts, :fonts, :fills, :borders, :cellStyleXfs, :cellXfs, :dxfs, :tableStyles
+  def test_ensure_locking
+    assert_equal(@styles.numFmts.locked_at, 2, "numFmts should be locked at 2")
+    assert_equal(@styles.fonts.locked_at, 1, "fonts should be locked at 1" )
+    assert_equal(@styles.fills.locked_at, 2, "fills should be locked at 2" )
+    assert_equal(@styles.borders.locked_at, 2, "borders should be locked at two" )
+    assert_equal(@styles.cellStyleXfs.locked_at, 1, "cellStyleXfs should be locked at two" )
+    assert_equal(@styles.cellXfs.locked_at, 1, "cellXfs should be locked at 1" )
+    assert_equal(@styles.dxfs.locked_at, 0, "dxfs should be locked at 0" )
+    assert_equal(@styles.tableStyles.locked_at, 0, "tableStyles should be locked at 0" )
+  end
+end

data/test/tc_validators.rb~

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'test/unit'
+require 'axlsx.rb'
+class TestValidators < Test::Unit::TestCase
+  def setup    
+  end
+  def teardown
+  end
+  
+  def test_validators
+    #unsigned_int
+    assert_nothing_raised { Axlsx.validate_unsigned_int 1 }
+    assert_nothing_raised { Axlsx.validate_unsigned_int +1 }
+    assert_raise(ArgumentError) { Axlsx.validate_unsigned_int -1 }
+    assert_raise(ArgumentError) { Axlsx.validate_unsigned_int '1' }
+    
+    #int
+    assert_nothing_raised { Axlsx.validate_int 1 }
+    assert_nothing_raised { Axlsx.validate_int -1 }
+    assert_raise(ArgumentError) { Axlsx.validate_int 'a' }
+    assert_raise(ArgumentError) { Axlsx.validate_int Array }
+ 
+    #boolean (as 0 or 1)
+    assert_nothing_raised { Axlsx.validate_boolean 0 }
+    assert_nothing_raised { Axlsx.validate_boolean 1 }
+    assert_raise(ArgumentError) { Axlsx.validate_boolean 2 }
+    assert_raise(ArgumentError) { Axlsx.validate_boolean false }
+
+    #string
+    assert_nothing_raised { Axlsx.validate_string "1" }
+    assert_raise(ArgumentError) { Axlsx.validate_string 2 }
+    assert_raise(ArgumentError) { Axlsx.validate_string false }
+
+    #float
+    assert_nothing_raised { Axlsx.validate_float 1.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_float 2 }
+    assert_raise(ArgumentError) { Axlsx.validate_float false }
+
+    #pattern_type
+    assert_nothing_raised { Axlsx.validate_pattern_type :none }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type "none" }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type "crazy_pattern" }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type false }
+
+    #gradient_type
+    assert_nothing_raised { Axlsx.validate_gradient_type :path }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type "fractal" }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type false }
+
+    #horizontal alignment
+    assert_nothing_raised { Axlsx.validate_horizontal_alignment :general }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment nil }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment "wavy" }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment false }
+
+    #vertical alignment
+    assert_nothing_raised { Axlsx.validate_vertical_alignment :top }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment nil }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment "dynamic" }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment false }
+
+    #contentType
+    assert_nothing_raised { Axlsx.validate_content_type Axlsx::WORKBOOK_CT }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type "http://some.url" }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type false }
+ 
+    #relationshipType
+    assert_nothing_raised { Axlsx.validate_relationship_type Axlsx::WORKBOOK_R }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type "http://some.url" }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type false }
+
+  end
+end
+