lib/ruby-1.9.1-rc1/test/csv/test_headers.rb

   1 #!/usr/bin/env ruby -w
   2 # encoding: UTF-8
   3
   4 # tc_headers.rb
   5 #
   6 #  Created by James Edward Gray II on 2005-10-31.
   7 #  Copyright 2005 James Edward Gray II. You can redistribute or modify this code
   8 #  under the terms of Ruby's license.
   9
  10 require "test/unit"
  11
  12 require "csv"
  13
  14 class TestCSVHeaders < Test::Unit::TestCase
  15   def setup
  16     @data = <<-END_CSV.gsub(/^\s+/, "")
  17     first,second,third
  18     A,B,C
  19     1,2,3
  20     END_CSV
  21   end
  22
  23   def test_first_row
  24     [:first_row, true].each do |setting|  # two names for the same setting
  25       # activate headers
  26       csv = nil
  27       assert_nothing_raised(Exception) do
  28         csv = CSV.parse(@data, headers: setting)
  29       end
  30
  31       # first data row - skipping headers
  32       row = csv[0]
  33       assert_not_nil(row)
  34       assert_instance_of(CSV::Row, row)
  35       assert_equal([%w{first A}, %w{second B}, %w{third C}], row.to_a)
  36
  37       # second data row
  38       row = csv[1]
  39       assert_not_nil(row)
  40       assert_instance_of(CSV::Row, row)
  41       assert_equal([%w{first 1}, %w{second 2}, %w{third 3}], row.to_a)
  42
  43       # empty
  44       assert_nil(csv[2])
  45     end
  46   end
  47
  48   def test_array_of_headers
  49     # activate headers
  50     csv = nil
  51     assert_nothing_raised(Exception) do
  52       csv = CSV.parse(@data, headers: [:my, :new, :headers])
  53     end
  54
  55     # first data row - skipping headers
  56     row = csv[0]
  57     assert_not_nil(row)
  58     assert_instance_of(CSV::Row, row)
  59     assert_equal( [[:my, "first"], [:new, "second"], [:headers, "third"]],
  60                   row.to_a )
  61
  62     # second data row
  63     row = csv[1]
  64     assert_not_nil(row)
  65     assert_instance_of(CSV::Row, row)
  66     assert_equal([[:my, "A"], [:new, "B"], [:headers, "C"]], row.to_a)
  67
  68     # third data row
  69     row = csv[2]
  70     assert_not_nil(row)
  71     assert_instance_of(CSV::Row, row)
  72     assert_equal([[:my, "1"], [:new, "2"], [:headers, "3"]], row.to_a)
  73
  74     # empty
  75     assert_nil(csv[3])
  76
  77     # with return and convert
  78     assert_nothing_raised(Exception) do
  79       csv = CSV.parse( @data, headers:           [:my, :new, :headers],
  80                               return_headers:    true,
  81                               header_converters: lambda { |h| h.to_s } )
  82     end
  83     row = csv[0]
  84     assert_not_nil(row)
  85     assert_instance_of(CSV::Row, row)
  86     assert_equal([["my", :my], ["new", :new], ["headers", :headers]], row.to_a)
  87     assert(row.header_row?)
  88     assert(!row.field_row?)
  89   end
  90
  91   def test_csv_header_string
  92     # activate headers
  93     csv = nil
  94     assert_nothing_raised(Exception) do
  95       csv = CSV.parse(@data, headers: "my,new,headers")
  96     end
  97
  98     # first data row - skipping headers
  99     row = csv[0]
 100     assert_not_nil(row)
 101     assert_instance_of(CSV::Row, row)
 102     assert_equal([%w{my first}, %w{new second}, %w{headers third}], row.to_a)
 103
 104     # second data row
 105     row = csv[1]
 106     assert_not_nil(row)
 107     assert_instance_of(CSV::Row, row)
 108     assert_equal([%w{my A}, %w{new B}, %w{headers C}], row.to_a)
 109
 110     # third data row
 111     row = csv[2]
 112     assert_not_nil(row)
 113     assert_instance_of(CSV::Row, row)
 114     assert_equal([%w{my 1}, %w{new 2}, %w{headers 3}], row.to_a)
 115
 116     # empty
 117     assert_nil(csv[3])
 118
 119     # with return and convert
 120     assert_nothing_raised(Exception) do
 121       csv = CSV.parse( @data, headers:           "my,new,headers",
 122                               return_headers:    true,
 123                               header_converters: :symbol )
 124     end
 125     row = csv[0]
 126     assert_not_nil(row)
 127     assert_instance_of(CSV::Row, row)
 128     assert_equal([[:my, "my"], [:new, "new"], [:headers, "headers"]], row.to_a)
 129     assert(row.header_row?)
 130     assert(!row.field_row?)
 131   end
 132
 133   def test_csv_header_string_inherits_separators
 134     # parse with custom col_sep
 135     csv = nil
 136     assert_nothing_raised(Exception) do
 137       csv = CSV.parse( @data.tr(",", "|"), col_sep: "|",
 138                                            headers: "my|new|headers" )
 139     end
 140
 141     # verify headers were recognized
 142     row = csv[0]
 143     assert_not_nil(row)
 144     assert_instance_of(CSV::Row, row)
 145     assert_equal([%w{my first}, %w{new second}, %w{headers third}], row.to_a)
 146   end
 147
 148   def test_return_headers
 149     # activate headers and request they are returned
 150     csv = nil
 151     assert_nothing_raised(Exception) do
 152       csv = CSV.parse(@data, headers: true, return_headers: true)
 153     end
 154
 155     # header row
 156     row = csv[0]
 157     assert_not_nil(row)
 158     assert_instance_of(CSV::Row, row)
 159     assert_equal( [%w{first first}, %w{second second}, %w{third third}],
 160                   row.to_a )
 161     assert(row.header_row?)
 162     assert(!row.field_row?)
 163
 164     # first data row - skipping headers
 165     row = csv[1]
 166     assert_not_nil(row)
 167     assert_instance_of(CSV::Row, row)
 168     assert_equal([%w{first A}, %w{second B}, %w{third C}], row.to_a)
 169     assert(!row.header_row?)
 170     assert(row.field_row?)
 171
 172     # second data row
 173     row = csv[2]
 174     assert_not_nil(row)
 175     assert_instance_of(CSV::Row, row)
 176     assert_equal([%w{first 1}, %w{second 2}, %w{third 3}], row.to_a)
 177     assert(!row.header_row?)
 178     assert(row.field_row?)
 179
 180     # empty
 181     assert_nil(csv[3])
 182   end
 183
 184   def test_converters
 185     # create test data where headers and fields look alike
 186     data = <<-END_MATCHING_CSV.gsub(/^\s+/, "")
 187     1,2,3
 188     1,2,3
 189     END_MATCHING_CSV
 190
 191     # normal converters do not affect headers
 192     csv = CSV.parse( data, headers:        true,
 193                            return_headers: true,
 194                            converters:     :numeric )
 195     assert_equal([%w{1 1}, %w{2 2}, %w{3 3}], csv[0].to_a)
 196     assert_equal([["1", 1], ["2", 2], ["3", 3]], csv[1].to_a)
 197     assert_nil(csv[2])
 198
 199     # header converters do affect headers (only)
 200     assert_nothing_raised(Exception) do
 201       csv = CSV.parse( data, headers:           true,
 202                              return_headers:    true,
 203                              converters:        :numeric,
 204                              header_converters: :symbol )
 205     end
 206     assert_equal([[:"1", "1"], [:"2", "2"], [:"3", "3"]], csv[0].to_a)
 207     assert_equal([[:"1", 1], [:"2", 2], [:"3", 3]], csv[1].to_a)
 208     assert_nil(csv[2])
 209   end
 210
 211   def test_builtin_downcase_converter
 212     csv = CSV.parse( "One,TWO Three", headers:           true,
 213                                       return_headers:    true,
 214                                       header_converters: :downcase )
 215     assert_equal(%w{one two\ three}, csv.headers)
 216   end
 217
 218   def test_builtin_symbol_converter
 219     csv = CSV.parse( "One,TWO Three", headers:           true,
 220                                       return_headers:    true,
 221                                       header_converters: :symbol )
 222     assert_equal([:one, :two_three], csv.headers)
 223   end
 224
 225   def test_custom_converter
 226     converter = lambda { |header| header.tr(" ", "_") }
 227     csv       = CSV.parse( "One,TWO Three",
 228                            headers:           true,
 229                            return_headers:    true,
 230                            header_converters: converter )
 231     assert_equal(%w{One TWO_Three}, csv.headers)
 232   end
 233
 234   def test_table_support
 235     csv = nil
 236     assert_nothing_raised(Exception) do
 237       csv = CSV.parse(@data, headers: true)
 238     end
 239
 240     assert_instance_of(CSV::Table, csv)
 241   end
 242
 243   def test_skip_blanks
 244     @data = <<-END_CSV.gsub(/^ +/, "")
 245
 246
 247     A,B,C
 248
 249     1,2,3
 250
 251
 252
 253     END_CSV
 254
 255     expected = [%w[1 2 3]]
 256     CSV.parse(@data, headers: true, skip_blanks: true) do |row|
 257       assert_equal(expected.shift, row.fields)
 258     end
 259
 260     expected = [%w[A B C], %w[1 2 3]]
 261     CSV.parse( @data,
 262                headers:        true,
 263                return_headers: true,
 264                skip_blanks:    true ) do |row|
 265       assert_equal(expected.shift, row.fields)
 266     end
 267   end
 268
 269   def test_headers_reader
 270     # no headers
 271     assert_nil(CSV.new(@data).headers)
 272
 273     # headers
 274     csv = CSV.new(@data, headers: true)
 275     assert_equal(true, csv.headers)                    # before headers are read
 276     csv.shift                                          # set headers
 277     assert_equal(%w[first second third], csv.headers)  # after headers are read
 278   end
 279
 280   def test_blank_row_bug_fix
 281     @data += "\n#{@data}"  # add a blank row
 282
 283     # ensure that everything returned is a Row object
 284     CSV.parse(@data, headers: true) do |row|
 285       assert_instance_of(CSV::Row, row)
 286     end
 287   end
 288 end