rexcel 0.1.1 → 0.1.2

data/unittest/test_rexcel_cell.rb

@@ -0,0 +1,126 @@
+#encoding: UTF-8
+#~ gem 'test-unit', ">= 2.1.2"  #tested with this version
+require_relative 'rexcel_test_helper'
+
+class Test_Cell < Test::Unit::TestCase
+  def test_create()
+    assert_nil( Excel::Cell.new().content)
+    assert_equal( 1, Excel::Cell.new(1).content)
+  end #def test_create()
+  def test_style()
+    style = Excel::Style.new('style_example')
+    assert_equal( nil, Excel::Cell.new(1).style)
+    assert_instance_of( Excel::Style, Excel::Cell.new(1, :style => style).style)
+    assert_equal( style, Excel::Cell.new(1, :style => style).style)
+  end
+  
+end #class Test_Cell
+
+class Test_Cell_xml < Test::Unit::TestCase
+  def setup()
+    @mock = Mock_document.new
+  end
+  def test_content_string
+    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"String\">content</ss:Data>\n  </ss:Cell>",
+      @mock.testcase{|builder, ns_proc|
+            cell = Excel::Cell.new('content')
+            cell.to_xml( builder,ns_proc)
+    })
+  end
+  def test_content_number
+    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"Number\">1</ss:Data>\n  </ss:Cell>",
+      @mock.testcase{|builder, ns_proc|
+            cell = Excel::Cell.new(1)
+            cell.to_xml( builder,ns_proc)
+    })
+    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"Number\">1.1</ss:Data>\n  </ss:Cell>",
+      @mock.testcase{|builder, ns_proc|
+            cell = Excel::Cell.new(1.1)
+            cell.to_xml( builder,ns_proc)
+    })
+    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"Number\">281474976710656</ss:Data>\n  </ss:Cell>",
+      @mock.testcase{|builder, ns_proc|
+            cell = Excel::Cell.new(281474976710656) #Bignum
+            cell.to_xml( builder,ns_proc)
+    })
+  end
+  def test_content_with_type
+    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"String\">1</ss:Data>\n  </ss:Cell>",
+      @mock.testcase{|builder, ns_proc|
+            cell = Excel::Cell.new(1, :string => true)
+            cell.to_xml( builder,ns_proc)
+    })
+  end #def test_content
+ 
+end #class Test_Cell_xlm
+
+class Test_Cell_xls < Test::Unit::TestCase
+  def setup()
+    wb = Excel::Excel.instance.xl.Workbooks.Add #Includes 3 worksheets
+    @ws = wb.ActiveSheet
+  end
+  def test_content_string_xls
+    cell = Excel::Cell.new('content')
+    cell_ole = cell.to_xls(@ws.Cells(1,1))    
+    assert_instance_of( WIN32OLE, cell_ole)    
+    assert_equal(XLS_ENCODING, cell_ole.value.encoding)
+    assert_equal('content', cell_ole.value)
+    assert_equal('@', cell_ole.NumberFormat)
+    
+  end #def test_content_string_xls
+  def test_content_number
+    cell_ole = Excel::Cell.new(1).to_xls(@ws.Cells(1,1))
+    assert_equal(1, cell_ole.value)
+    assert_equal(XLS_ENCODING, cell_ole.NumberFormat.encoding)
+    assert_equal("Standard".encode(XLS_ENCODING), cell_ole.NumberFormat)
+
+    cell_ole = Excel::Cell.new(1.1).to_xls(@ws.Cells(1,2))
+    assert_equal(1.1, cell_ole.value)
+    assert_equal("Standard".encode(XLS_ENCODING), cell_ole.NumberFormat)
+
+    #Bignum
+    cell_ole = Excel::Cell.new(281474976710656).to_xls(@ws.Cells(1,3))
+    assert_equal(281474976710656, cell_ole.value)
+    assert_equal("Standard".encode(XLS_ENCODING), cell_ole.NumberFormat)
+  end
+  def test_content_with_type
+    cell_ole = Excel::Cell.new(1, :string => true ).to_xls(@ws.Cells(1,1))
+    assert_equal('1', cell_ole.value)
+    assert_equal('@', cell_ole.NumberFormat)
+  end #def test_content
+end #class Test_Cell_xls
+
+class Test_Cell_csv < Test::Unit::TestCase
+  def setup()
+    #~ wb = Excel::Excel.instance.xl.Workbooks.Add #Includes 3 worksheets
+    #~ @ws = wb.ActiveSheet
+  end
+  def test_content_string_csv
+    cell = Excel::Cell.new('content')
+    assert_equal('String', cell.type)    
+    assert_equal('content', cell.to_csv())    
+
+    cell = Excel::Cell.new('1')
+    assert_equal('String', cell.type)    
+    assert_equal('"1"', cell.to_csv())    
+  end #def test_content_string_csv
+  
+  def test_content_number
+    cell = Excel::Cell.new(1)
+    assert_equal('Number', cell.type)    
+    assert_equal(1, cell.to_csv())    
+  end
+  
+  def test_content_float
+    cell = Excel::Cell.new(1.1)
+    assert_equal('Number', cell.type)    
+    assert_equal('="1.1"', cell.to_csv())    
+  end
+  
+  def test_content_with_type
+    cell = Excel::Cell.new(1, :string => true )
+    assert_equal('String', cell.type)    
+    assert_equal('"1"', cell.to_csv)
+  end #def test_content
+  
+end #class Test_Cell_csv

data/unittest/test_rexcel_row.rb

@@ -0,0 +1,103 @@
+#encoding: UTF-8
+require_relative 'rexcel_test_helper'
+
+
+class Test_Row < Test::Unit::TestCase
+  def test_style()
+    style = Excel::Style.new('style_example')
+    assert_equal( nil, Excel::Row.new.style)
+    assert_instance_of( Excel::Style, Excel::Row.new(:style => style).style)
+    assert_equal( style, Excel::Row.new(:style => style).style)
+  end
+end
+
+class Test_Row_insertions < Test::Unit::TestCase
+  def setup()
+    @mock = Mock_document.new
+  end
+  def test_insert_array
+    row = Excel::Row.new()
+    assert_equal(0, row.columns.size)
+    assert_nothing_raised{ row <<  [:a,:b,:c,:d] }
+    assert_equal(%{<ss:Row>
+    <ss:Cell>
+      <ss:Data ss:Type="String">a</ss:Data>
+    </ss:Cell>
+    <ss:Cell>
+      <ss:Data ss:Type="String">b</ss:Data>
+    </ss:Cell>
+    <ss:Cell>
+      <ss:Data ss:Type="String">c</ss:Data>
+    </ss:Cell>
+    <ss:Cell>
+      <ss:Data ss:Type="String">d</ss:Data>
+    </ss:Cell>
+  </ss:Row>},
+      @mock.testcase{|builder, ns_proc|
+        row.to_xml( builder,ns_proc)
+    })
+    assert_equal(4, row.columns.size)
+    assert_equal("a;b;c;d", row.to_csv())           
+    assert_nothing_raised{ row <<  [:a,:b,:c,:d] }
+  end
+  def test_insert_hash()
+    row = Excel::Row.new()
+    assert_equal(0, row.columns.size)
+    #Hash requires Heading data
+    assert_raise( ArgumentError ){ row <<  { 1 => 1, 2 => 2, 3 => 3 } }
+    assert_equal(0, row.columns.size)
+  end #def test_insert()
+  def test_insert_other()
+    row = Excel::Row.new()
+    assert_equal(0, row.columns.size)
+    assert_raise(Excel::EmptyError){
+      @mock.testcase{|builder, ns_proc|row.to_xml( builder,ns_proc)}
+    }
+    assert_nothing_raised{ row << 'a' }
+    assert_equal(1, row.columns.size)
+    assert_equal(%{<ss:Row>
+    <ss:Cell>
+      <ss:Data ss:Type="String">a</ss:Data>
+    </ss:Cell>
+  </ss:Row>},
+      @mock.testcase{|builder, ns_proc|
+        row.to_xml( builder,ns_proc)
+    })    
+    assert_equal("a", row.to_csv())           
+    assert_nothing_raised{ row << 'x' }
+    assert_equal(2, row.columns.size)
+    assert_equal(%{<ss:Row>
+    <ss:Cell>
+      <ss:Data ss:Type="String">a</ss:Data>
+    </ss:Cell>
+    <ss:Cell>
+      <ss:Data ss:Type="String">x</ss:Data>
+    </ss:Cell>
+  </ss:Row>},
+      @mock.testcase{|builder, ns_proc|
+        row.to_xml( builder,ns_proc)
+    })
+    assert_equal("a;x", row.to_csv())           
+  end
+  def test_insert_errors()  
+    row = Excel::Row.new()
+    assert_raise(ArgumentError){ row << Excel::Row.new()  }
+    assert_raise(ArgumentError){ row << Excel::Worksheet.new()  }
+    assert_raise(ArgumentError){ row << Excel::Workbook.new()  }
+  end
+  
+  #~ def test_bold()
+    #~ pend("#{self.class}##{__method__} output")
+  #~ end
+  #~ def test_italic()
+    #~ pend("#{self.class}##{__method__} output")
+  #~ end
+  #~ def test_color()
+    #~ pend("#{self.class}##{__method__} output")
+  #~ end
+  #~ def test_backgroundcolor()
+    #~ pend("#{self.class}##{__method__} output")
+  #~ end
+
+end #class Test_Row
+

data/unittest/test_rexcel_workbook.rb

@@ -0,0 +1,293 @@
+#encoding: UTF-8
+require_relative 'rexcel_test_helper'
+
+class Test_Workbook < Test::Unit::TestCase
+  #List of temporary generated files
+  FILELIST = %w{
+    test_save_xml.xml test_save_xml.xls test_save_xml.xlsx test_save_xml_2.xls 
+    test_save_csv.csv test_save_csv.xls test_save_csv.xlsx test_save_csv_2.xls
+    test_save.xls test_save.xlsx}
+        
+  def setup()
+    FILELIST.each{|fn|
+      File.delete(fn) if File.exist?(fn)
+    }
+  end
+  def teardown()
+    FILELIST.each{|fn|
+      File.delete(fn) if File.exist?(fn)
+    }
+  end
+  def test_init()
+    assert_nothing_raised{ Excel::Workbook.new() }
+    assert_nothing_raised{ Excel::Workbook.new( Excel::LOGGER) }
+    assert_raise(ArgumentError){ Excel::Workbook.new( 1 ) }
+  end
+  
+  def test_save_xml()
+    
+    assert_false( File.exist?('test_save_xml.xml'), 'Old testdata found')
+    assert_false( File.exist?('test_save_xml.xls'), 'Old testdata found')
+    assert_false( File.exist?('test_save_xml.xlsx'), 'Old testdata found')
+
+    wb = Excel::Workbook.new()
+    wb << [1,2,3] #add anything, else you get an error
+    wb << ['a','b','c'] #add anything, else you get an error
+    assert_nothing_raised{ wb.save('test_save_xml.xml') }
+    assert_nothing_raised{ wb.save('test_save_xml.xls', 'test_save_xml.xml')}
+    assert_nothing_raised{ wb.save('test_save_xml.xlsx', 'test_save_xml.xml')}
+    assert_nothing_raised{ wb.save('test_save_xml_2.xls')}
+
+    assert_true( File.exist?('test_save_xml.xml'))
+    assert_true( File.exist?('test_save_xml.xls'))
+    assert_true( File.exist?('test_save_xml.xlsx'))
+
+
+    #~ assert_equal_filecontent( "expected/%s-%s.xml" %[self.class, __method__], 
+                                        #~ wb.build_excel_xml('ss') )
+    assert_equal( %{<?xml version="1.0"?>
+<ss:Workbook xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
+    <ss:Worksheet ss:Name="Sheet0">
+        <ss:Table>
+            <ss:Row>
+                <ss:Cell>
+                    <ss:Data ss:Type="Number">1</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="Number">2</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="Number">3</ss:Data>
+                </ss:Cell>
+            </ss:Row>
+            <ss:Row>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">a</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">b</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">c</ss:Data>
+                </ss:Cell>
+            </ss:Row>
+        </ss:Table>
+    </ss:Worksheet>
+</ss:Workbook>}, 
+    wb.build_excel_xml('ss') )
+    
+    assert_equal( 2, compare_with_bc3('test_save_xml.xls', 'test_save_xml.xlsx'))
+    assert_equal( 2, compare_with_bc3('test_save_xml.xls', 'test_save_xml_2.xls'),
+          "Save directly xls is different to save via x")
+
+  end
+  
+  def test_save_csv()
+    
+    assert_false( File.exist?('test_save_csv.csv'), 'Old testdata found')
+    assert_false( File.exist?('test_save_csv.xls'), 'Old testdata found')
+    assert_false( File.exist?('test_save_csv.xlsx'), 'Old testdata found')
+
+    wb = Excel::Workbook.new()
+    wb << [1,2,3] #add anything, else you get an error
+    wb << ['a','b','c'] #add anything, else you get an error
+    assert_nothing_raised{ wb.save('test_save_csv.csv') }
+    assert_nothing_raised{ wb.save('test_save_csv.xls', 'test_save_csv.csv')}
+    assert_nothing_raised{ wb.save('test_save_csv.xlsx', 'test_save_csv.csv')}
+    assert_nothing_raised{ wb.save('test_save_csv_2.xls') }
+
+    assert_true( File.exist?('test_save_csv.csv'))
+    assert_true( File.exist?('test_save_csv.xls'))
+    assert_true( File.exist?('test_save_csv.xlsx'))
+    assert_true( File.exist?('test_save_csv_2.xls'))
+                                        
+    assert_equal("1;2;3\na;b;c", wb.build_excel_csv())
+    assert_equal( 2, compare_with_bc3('test_save_csv.xls', 'test_save_csv.xlsx'))
+
+    assert_equal( 2, compare_with_bc3('test_save_csv.xls', 'test_save_csv_2.xls'),
+          "Save directly xls is different to save via csv")
+          
+  end
+  
+  
+  def test_save_xls()
+    
+    assert_false( File.exist?('test_save.xls'), 'Old testdata found')
+    assert_false( File.exist?('test_save.xlsx'), 'Old testdata found')
+
+    wb = Excel::Workbook.new()
+    wb << [ 1,2,3,4]
+    wb << [ :a, :b, :c ]
+    assert_nothing_raised{ wb.save('test_save.xls')}
+    assert_nothing_raised{ wb.save('test_save.xlsx')}
+    
+    assert_true( File.exist?('test_save.xls'))
+    assert_true( File.exist?('test_save.xlsx'))
+
+    assert_false( File.exist?('test_save.xml'))
+    assert_false( File.exist?('test_save_xml.xls'))
+    assert_nothing_raised{ wb.save('test_save_xml.xml')}
+    assert_nothing_raised{ wb.save('test_save_xml.xlsx', 'test_save_xml.xml')}
+    assert_true( File.exist?('test_save_xml.xml'))
+    assert_true( File.exist?('test_save_xml.xlsx'))
+    
+    assert_equal( 2, compare_with_bc3('test_save.xls', 'test_save.xlsx'))
+
+  end #def test_create_wb()
+
+  def test_save_other()
+    wb = Excel::Workbook.new()
+    assert_raise( ArgumentError ){wb.save('test_save_xml.doc')}
+  end
+end #class Test_workbook 
+
+class Test_workbook_insertions < Test::Unit::TestCase
+  def test_insert_worksheet()
+    wb = Excel::Workbook.new()
+    assert_equal(0, wb.worksheets.size)
+    
+    assert_nothing_raised{ wb << Excel::Worksheet.new()  }    
+    assert_equal(1, wb.worksheets.size)
+    assert_equal('Sheet', wb.worksheets.last.name)
+    
+    assert_nothing_raised{ wb << Excel::Worksheet.new('Sheet for test')  }
+    assert_equal(2, wb.worksheets.size)
+    assert_equal('Sheet for test', wb.worksheets.last.name)
+  end
+  def test_insert_array
+    wb = Excel::Workbook.new()
+    assert_equal(0, wb.worksheets.size)
+    assert_nothing_raised{ wb <<  [:a,:b,:c,:d] }
+    assert_equal(1, wb.worksheets.size)
+    assert_equal(%{<?xml version="1.0"?>
+<ss:Workbook xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
+    <ss:Worksheet ss:Name="Sheet0">
+        <ss:Table>
+            <ss:Row>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">a</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">b</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">c</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">d</ss:Data>
+                </ss:Cell>
+            </ss:Row>
+        </ss:Table>
+    </ss:Worksheet>
+</ss:Workbook>},
+        wb.build_excel_xml( 'ss' )
+    )
+    assert_equal("a;b;c;d", wb.build_excel_csv())           
+    assert_nothing_raised{ wb <<  [:a,:b,:c,:d] }
+  end
+  def test_insert_row()
+    wb = Excel::Workbook.new()
+    assert_equal(0, wb.worksheets.size)
+    assert_nothing_raised{ wb <<  Excel::Row.new() }
+    assert_equal(1, wb.worksheets.size)
+    #Exception for empty row
+    assert_raise( Excel::EmptyError ){ wb.build_excel_xml( 'ns' ) }
+  end  
+  def test_insert_hash()
+    wb = Excel::Workbook.new()
+    assert_equal(0, wb.worksheets.size)
+    assert_equal(nil, wb.active_worksheet)
+    #Hash requires Heading data
+    assert_raise( ArgumentError ){ wb <<  { 1 => :a, 2 => :b, 3 => :c } }
+    assert_equal(1, wb.worksheets.size)
+    assert_instance_of(Excel::Worksheet, wb.active_worksheet)
+    
+    ws = wb.active_worksheet
+    ws << Excel::Column.new( 1 )
+    ws << Excel::Column.new( 2 )
+    
+    assert_nothing_raised{ wb <<  { 1 => :a, 2 => :b, 3 => :c } }
+    assert_equal(1, wb.worksheets.size)#no new worksheet created
+    assert_equal(%{<?xml version="1.0"?>
+<ss:Workbook xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
+    <ss:Worksheet ss:Name="Sheet0">
+        <ss:Table>
+            <ss:Column/>
+            <ss:Column/>
+            <ss:Row>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">a</ss:Data>
+                </ss:Cell>
+                <ss:Cell>
+                    <ss:Data ss:Type="String">b</ss:Data>
+                </ss:Cell>
+            </ss:Row>
+        </ss:Table>
+    </ss:Worksheet>
+</ss:Workbook>},
+        wb.build_excel_xml( 'ss' )
+    )       
+    assert_equal("a;b", wb.build_excel_csv())           
+
+  end #def test_insert()
+  def test_insert_other()
+    wb = Excel::Workbook.new()
+    assert_raise(ArgumentError){ wb << 1 }
+  end
+
+end #class Test_workbook_insertion
+
+
+class Test_Workbook_to_csv < Test::Unit::TestCase
+  def setup()
+    @wb = Excel::Workbook.new()
+    @wb << ws = Excel::Worksheet.new()
+    ws <<  [:a,:b,:c,:d]
+    ws <<  %w{a b c d}
+    ws <<  [1,2,3,4]
+    ws <<  [1.1,2.2,3.3,4.4]
+    #~ ws <<  %w{1,1 2,2 3,3 4,4}
+  end  
+  def teardown()
+  end
+  def test_to_csv
+    assert_equal(%{a;b;c;d\na;b;c;d\n1;2;3;4\n="1.1";="2.2";="3.3";="4.4"}, @wb.build_excel_csv())
+  end
+  def test_to_csv_sep
+    assert_equal(%{a\tb\tc\td\na\tb\tc\td\n1\t2\t3\t4\n="1.1"\t="2.2"\t="3.3"\t="4.4"}, @wb.build_excel_csv(:sep => "\t"))
+    assert_equal(%{a,b,c,d\na,b,c,d\n1,2,3,4\n="1.1",="2.2",="3.3",="4.4"}, @wb.build_excel_csv(:sep => ','))
+    
+    assert_raise(ArgumentError){@wb.build_excel_csv(:sep => 'a')}
+  end
+  
+  def test_filename()
+    filename = "#{self.class.name}-#{__method__}.csv"
+    File.delete(filename) if File.exist?(filename)
+    assert_false(File.exist?(filename))
+    @wb.build_excel_csv(:filename => filename)
+    assert_true(File.exist?(filename))
+    assert_equal_filecontent(File.join('expected', filename), @wb.build_excel_csv)
+    #~ assert_equal_filecontent(File.join('expected', filename), File.read(filename, :encoding => 'UTF-16LE'))
+    File.delete(filename)
+  end
+  
+  def test_filename_encoding()
+    filename = "#{self.class.name}-#{__method__}.csv"
+    File.delete(filename) if File.exist?(filename)
+    assert_false(File.exist?(filename))
+    @wb.build_excel_csv(:filename => filename, :encoding => 'utf-8')
+    assert_true(File.exist?(filename))
+    assert_equal_filecontent(File.join('expected', filename), File.read(filename, :encoding => 'UTF-8'))
+    File.delete(filename)
+  end
+  
+  def test_multiple_worksheets()
+    @wb << ws = Excel::Worksheet.new()
+    ws <<  [:a,:b,:c,:d]
+    assert_raise(ArgumentError, 'csv not possible for multiple worksheets'){ @wb.build_excel_csv }
+  end
+  def test_multiple_worksheets_empty()
+    @wb << ws = Excel::Worksheet.new()
+    assert_nothing_raised(ArgumentError, 'csv possible for multiple worksheets, when only one filled'){ @wb.build_excel_csv }
+  end
+end #class Test_Workbook_to_csv