ndr_import 8.5.0 → 8.5.1

data/test/file/pdf_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-require 'ndr_import/file/pdf'
-
-module NdrImport
-  module File
-    # PDF file handler tests
-    class PdfTest < ActiveSupport::TestCase
-      def setup
-        @permanent_test_files = SafePath.new('permanent_test_files')
-      end
-
-      test 'should read pdf correctly' do
-        file_path = @permanent_test_files.join('hello_world.pdf')
-        handler = NdrImport::File::Pdf.new(file_path, nil)
-        handler.tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-          assert_equal ['Hello                                         World', '',
-                        'Goodbye                                       Universe'], sheet.to_a
-        end
-      end
-
-      test 'should raise exception on invalid pdf file' do
-        assert_raises RuntimeError do
-          file_path = @permanent_test_files.join('not_a_pdf.pdf')
-          handler = NdrImport::File::Pdf.new(file_path, nil)
-          handler.tables.each do |tablename, sheet|
-            assert_nil tablename
-            assert_instance_of Enumerator, sheet
-            sheet.to_a
-          end
-        end
-      end
-    end
-  end
-end

data/test/file/registry_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-require 'ndr_import/file/registry'
-
-module NdrImport
-  module File
-    # Registry file handler tests
-    class RegistryTest < ActiveSupport::TestCase
-      def setup
-        @home = SafePath.new('test_space_rw')
-        @permanent_test_files = SafePath.new('permanent_test_files')
-      end
-
-      test 'Registry.handlers' do
-        assert_instance_of Hash, NdrImport::File::Registry.handlers
-        assert_equal %w[7z acroform csv delimited doc docx nontabular
-                        pdf text txt xls xlsx xml_table zip],
-                     NdrImport::File::Registry.handlers.keys.sort
-      end
-
-      test 'should fail to enumerate unknown format' do
-        exception = assert_raises(RuntimeError) do
-          file_path = @permanent_test_files.join('normal.csv')
-          tables = NdrImport::File::Registry.tables(file_path, 'mp3')
-          tables.each do |tablename, sheet|
-            assert_nil tablename
-            sheet.to_a
-          end
-        end
-
-        assert_equal 'Error: Unknown file format "mp3"', exception.message
-      end
-
-      test 'should enumerate pdf file table' do
-        file_path = @permanent_test_files.join('hello_world.pdf')
-        tables = NdrImport::File::Registry.tables(file_path, nil)
-        tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-          assert_equal ['Hello                                         World', '',
-                        'Goodbye                                       Universe'], sheet.to_a
-        end
-      end
-
-      test 'should enumerate zip file tables' do
-        options = { 'unzip_path' => @home }
-        file_path = @permanent_test_files.join('normal.csv.zip')
-        files = NdrImport::File::Registry.files(file_path, options)
-        files.each do |filename|
-          tables = NdrImport::File::Registry.tables(filename, nil, options)
-
-          tables.each do |tablename, sheet|
-            assert_nil tablename
-            sheet = sheet.to_a
-            assert_equal(('A'..'Z').to_a, sheet[0])
-            assert_equal ['1'] * 26, sheet[1]
-            assert_equal ['2'] * 26, sheet[2]
-          end
-        end
-      end
-    end
-  end
-end

data/test/file/seven_zip_test.rb

@@ -1,59 +0,0 @@
-require 'test_helper'
-require 'ndr_import/file/seven_zip'
-
-module NdrImport
-  module File
-    # 7zip file handler tests
-    class SevenZipTestTest < ActiveSupport::TestCase
-      def setup
-        @home = SafePath.new('test_space_rw')
-        @permanent_test_files = SafePath.new('permanent_test_files')
-      end
-
-      test 'should reject non SafePath arguments' do
-        file_path = @home.join('imaginary.7z')
-
-        assert_raises ArgumentError do
-          NdrImport::File::SevenZip.new(file_path.to_s, nil, 'unzip_path' => @home.to_s)
-        end
-
-        assert_raises ArgumentError do
-          NdrImport::File::SevenZip.new(file_path.to_s, nil, 'unzip_path' => @home)
-        end
-
-        assert_raises ArgumentError do
-          NdrImport::File::SevenZip.new(file_path, nil, 'unzip_path' => @home.to_s)
-        end
-      end
-
-      test 'should read 7zip file with correct password' do
-        options = { 'password' => 'FortuneCookie', 'unzip_path' => @home }
-        file_path = @permanent_test_files.join('normal.7z')
-
-        handler = NdrImport::File::SevenZip.new(file_path, nil, options)
-        handler.files.all? do |filename|
-          assert_instance_of SafePath, filename
-        end
-        files = handler.files.to_a
-        assert_equal 'normal_pipe.csv', ::File.basename(files[0])
-        assert_equal 'normal_thorn.csv', ::File.basename(files[1])
-
-        exception = assert_raises RuntimeError do
-          handler.tables
-        end
-        assert_equal 'SevenZip#tables should never be called', exception.message
-      end
-
-      test 'should not read 7zip file with incorrect password' do
-        options = { 'password' => 'WrongPassword', 'unzip_path' => @home }
-        file_path = @permanent_test_files.join('normal.7z')
-
-        handler = NdrImport::File::SevenZip.new(file_path, nil, options)
-
-        assert_raises SevenZipRuby::InvalidArchive do
-          handler.files.to_a
-        end
-      end
-    end
-  end
-end

data/test/file/text_test.rb

@@ -1,92 +0,0 @@
-# encoding: UTF-8
-require 'test_helper'
-require 'ndr_import/file/text'
-
-module NdrImport
-  module File
-    # Text file handler tests
-    class TextTest < ActiveSupport::TestCase
-      def setup
-        @permanent_test_files = SafePath.new('permanent_test_files')
-      end
-
-      test 'should read text file' do
-        file_path = @permanent_test_files.join('hello_world.txt')
-        handler = NdrImport::File::Text.new(file_path, nil)
-        handler.tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-          assert_equal ['Hello world,', 'this is a text document'], sheet.to_a
-        end
-      end
-
-      test 'should read text file with UTF-8 encoding' do
-        file_path = @permanent_test_files.join('hello_utf8.txt')
-        handler = NdrImport::File::Text.new(file_path, nil)
-        handler.tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-
-          lines = sheet.to_a
-
-          assert_equal ['Hello world', 'This is a thorny þ issue!'], lines
-          assert lines.all? { |line| line.encoding.name == 'UTF-8' && line.valid_encoding? }
-        end
-      end
-
-      test 'should read text file with UTF-16 [BE] encoding' do
-        file_path = @permanent_test_files.join('hello_utf16be.txt')
-        handler = NdrImport::File::Text.new(file_path, nil)
-        handler.tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-
-          lines = sheet.to_a
-
-          assert_equal ['Hello world', 'This is a thorny þ issue!'], lines
-          assert lines.all? { |line| line.encoding.name == 'UTF-8' && line.valid_encoding? }
-        end
-      end
-
-      test 'should read text file with UTF-16 [LE] encoding' do
-        file_path = @permanent_test_files.join('hello_utf16le.txt')
-        handler = NdrImport::File::Text.new(file_path, nil)
-        handler.tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-
-          lines = sheet.to_a
-
-          assert_equal ['Hello world', 'This is a thorny þ issue!'], lines
-          assert lines.all? { |line| line.encoding.name == 'UTF-8' && line.valid_encoding? }
-        end
-      end
-
-      test 'should read text file with Windows-1252 encoding' do
-        file_path = @permanent_test_files.join('hello_windows.txt')
-        handler = NdrImport::File::Text.new(file_path, nil)
-        handler.tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-
-          lines = sheet.to_a
-
-          assert_equal ['Hello windows world', 'This is a thorny þ issue!'], lines
-          assert lines.all? { |line| line.encoding.name == 'UTF-8' && line.valid_encoding? }
-        end
-      end
-
-      test 'should raise exception on invalid text file' do
-        assert_raises RuntimeError do
-          file_path = @permanent_test_files.join('hello_world.pdf')
-          handler = NdrImport::File::Text.new(file_path, nil)
-          handler.tables.each do |tablename, sheet|
-            assert_nil tablename
-            assert_instance_of Enumerator, sheet
-            sheet.to_a
-          end
-        end
-      end
-    end
-  end
-end

data/test/file/word_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-require 'ndr_import/file/word'
-
-module NdrImport
-  module File
-    # Word document file handler tests
-    class WordTest < ActiveSupport::TestCase
-      def setup
-        @permanent_test_files = SafePath.new('permanent_test_files')
-      end
-
-      test 'should read word file' do
-        file_path = @permanent_test_files.join('hello_world.doc')
-        handler = NdrImport::File::Word.new(file_path, nil)
-        handler.tables.each do |tablename, sheet|
-          assert_nil tablename
-          assert_instance_of Enumerator, sheet
-          assert_equal ['Hello world, this is a word document'], sheet.to_a
-        end
-      end
-
-      test 'should raise exception on invalid word file' do
-        assert_raises RuntimeError do
-          file_path = @permanent_test_files.join('not_a_word_file.doc')
-          handler = NdrImport::File::Word.new(file_path, nil)
-          handler.tables.each do |tablename, sheet|
-            assert_nil tablename
-            assert_instance_of Enumerator, sheet
-            sheet.to_a
-          end
-        end
-      end
-    end
-  end
-end

data/test/file/xml_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-require 'ndr_import/file/xml'
-
-module NdrImport
-  module File
-    # Xml file handler tests
-    class XmlTest < ActiveSupport::TestCase
-      def setup
-        @permanent_test_files = SafePath.new('permanent_test_files')
-      end
-
-      test 'should return enum of xml elements' do
-        file_path = @permanent_test_files.join('sample.xml')
-        handler   = NdrImport::File::Xml.new(file_path, nil, 'xml_record_xpath' => 'root/record')
-        rows      = handler.send(:rows)
-        assert rows.is_a? Enumerator
-        assert(rows.all? { |row| row.is_a? Nokogiri::XML::Element })
-      end
-    end
-  end
-end

data/test/file/zip_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-require 'ndr_import/file/zip'
-require 'zip'
-
-module NdrImport
-  module File
-    # Zip file handler tests
-    class ZipTest < ActiveSupport::TestCase
-      def setup
-        @home = SafePath.new('test_space_rw')
-        @permanent_test_files = SafePath.new('permanent_test_files')
-      end
-
-      test 'should reject non SafePath arguments' do
-        file_path = @home.join('imaginary.zip')
-
-        assert_raises ArgumentError do
-          NdrImport::File::Zip.new(file_path.to_s, nil, 'unzip_path' => @home.to_s)
-        end
-
-        assert_raises ArgumentError do
-          NdrImport::File::Zip.new(file_path.to_s, nil, 'unzip_path' => @home)
-        end
-
-        assert_raises ArgumentError do
-          NdrImport::File::Zip.new(file_path, nil, 'unzip_path' => @home.to_s)
-        end
-      end
-
-      test 'should read table correctly' do
-        options = { 'unzip_path' => @home }
-        file_path = @permanent_test_files.join('normal.csv.zip')
-
-        handler = NdrImport::File::Zip.new(file_path, nil, options)
-        handler.files.each do |filename|
-          assert_instance_of SafePath, filename
-          assert_equal 'normal.csv', ::File.basename(filename)
-        end
-
-        exception = assert_raises RuntimeError do
-          handler.tables
-        end
-        assert_equal 'Zip#tables should never be called', exception.message
-      end
-    end
-  end
-end

data/test/fixed_width/table_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-
-# This tests the NdrImport::FixedWidth::Table mapping class
-module FixedWidth
-  class TableTest < ActiveSupport::TestCase
-    def test_transform_fixed_width_line
-      table = NdrImport::FixedWidth::Table.new(header_lines: 2,
-                                               footer_lines: 1,
-                                               klass: 'SomeTestKlass',
-                                               columns: fixed_width_column_mapping)
-
-      enum = table.transform_line('123  abcdexyz', 2)
-      assert_instance_of Enumerator, enum
-      output = []
-      enum.each do |klass, fields, index|
-        output << [klass, fields, index]
-      end
-
-      expected_output = [
-        ['SomeTestKlass', { rawtext: { 'one' => '123  ', 'two' => 'abcde', 'three' => 'xyz' } }, 2]
-      ]
-      assert_equal expected_output.sort, output.sort
-    end
-
-    private
-
-    def fixed_width_column_mapping
-      [
-        { 'column' => 'one',   'unpack_pattern' => 'a5' },
-        { 'column' => 'two',   'unpack_pattern' => 'a5' },
-        { 'column' => 'three', 'unpack_pattern' => 'a3' }
-      ]
-    end
-  end
-end

data/test/helpers/file/delimited_test.rb

@@ -1,105 +0,0 @@
-require 'test_helper'
-require 'ndr_import/helpers/file/delimited'
-
-# Delimited file helper tests
-class DelimitedTest < ActiveSupport::TestCase
-  # This is a test importer class to test the Delimited file helper mixin
-  class TestImporter
-    include NdrImport::Helpers::File::Delimited
-  end
-
-  def setup
-    @permanent_test_files = SafePath.new('permanent_test_files')
-    @importer = TestImporter.new
-  end
-
-  test 'should read csv correctly' do
-    rows = @importer.read_delimited_file(@permanent_test_files.join('normal.csv'), nil)
-    assert_equal(('A'..'Z').to_a, rows[0])
-    assert_equal ['1'] * 26, rows[1]
-    assert_equal ['2'] * 26, rows[2]
-  end
-
-  test 'should read csv with a BOM' do
-    rows = @importer.read_delimited_file(@permanent_test_files.join('bomd.csv'), nil)
-    assert_equal(('A'..'Z').to_a, rows[0])
-    assert_equal ['1'] * 26, rows[1]
-    assert_equal ['2'] * 26, rows[2]
-  end
-
-  test 'should read windows-1252 csv' do
-    rows = @importer.read_delimited_file(@permanent_test_files.join('windows.csv'), nil)
-    assert_equal 1, rows.length
-  end
-
-  test 'should read acsii-delimited csv' do
-    rows = @importer.read_delimited_file(@permanent_test_files.join('high_ascii_delimited.txt'),
-                                         "\xfe")
-    assert_equal 2, rows.length
-  end
-
-  test 'should read line-by-line' do
-    rows = []
-    @importer.delimited_rows(@permanent_test_files.join('normal.csv')) { |row| rows << row }
-    assert_equal(('A'..'Z').to_a, rows[0])
-    assert_equal ['1'] * 26, rows[1]
-    assert_equal ['2'] * 26, rows[2]
-  end
-
-  test 'should read line-by-line with custom delimiter' do
-    count = 0
-    file  = @permanent_test_files.join('high_ascii_delimited.txt')
-
-    @importer.delimited_rows(file, "\xfe") { count += 1 }
-    assert_equal 2, count
-  end
-
-  test 'should report addition details upon failure to slurp csv' do
-    exception = assert_raises(CSVLibrary::MalformedCSVError) do
-      @importer.read_delimited_file(@permanent_test_files.join('broken.csv'), nil)
-    end
-
-    assert_match(/Invalid CSV format on row 2 of broken\.csv\./, exception.message)
-    assert_match(CORRUPTED_QUOTES_MESSAGE_PATTERN, exception.message)
-    assert_match(/in line 2/, exception.message)
-  end
-
-  test 'should be able to use liberal parsing to overcome minor CSV errors' do
-    file_path = @permanent_test_files.join('malformed.csv')
-    assert_raises(CSVLibrary::MalformedCSVError) do
-      @importer.read_delimited_file(file_path, nil)
-    end
-
-    rows = @importer.read_delimited_file(file_path, nil, true)
-
-    expected_row = ['2'] * 25
-    expected_row << '2"malformed"'
-    assert_equal expected_row, rows[2].sort
-  end
-
-  test 'should report addition details upon failure to read csv line-by-line' do
-    rows_yielded = []
-    exception    = assert_raises(CSVLibrary::MalformedCSVError) do
-      @importer.delimited_rows(@permanent_test_files.join('broken.csv')) do |row|
-        rows_yielded << row
-      end
-    end
-
-    assert rows_yielded.empty?, 'no rows should have been yielded'
-
-    assert_match(/Invalid CSV format on row 2 of broken\.csv\./, exception.message)
-    assert_match(CORRUPTED_QUOTES_MESSAGE_PATTERN, exception.message)
-    assert_match(/in line 2/, exception.message)
-  end
-
-  test 'delimited_tables should read table correctly' do
-    table = @importer.send(:delimited_tables, @permanent_test_files.join('normal.csv'))
-    table.each do |tablename, sheet|
-      assert_nil tablename
-      sheet = sheet.to_a
-      assert_equal(('A'..'Z').to_a, sheet[0])
-      assert_equal ['1'] * 26, sheet[1]
-      assert_equal ['2'] * 26, sheet[2]
-    end
-  end
-end