iostreams 0.14.0 → 0.15.0

data/test/line_reader_test.rb

@@ -0,0 +1,105 @@
+require_relative 'test_helper'
+
+class LineReaderTest < Minitest::Test
+  describe IOStreams::Line::Reader do
+    let :file_name do
+      File.join(File.dirname(__FILE__), 'files', 'text.txt')
+    end
+
+    let :data do
+      data = []
+      File.open(file_name, 'rt') do |file|
+        while !file.eof?
+          data << file.readline.strip
+        end
+      end
+      data
+    end
+
+    describe '#initialize' do
+      it 'does not strip invalid characters' do
+        bad_lines = [
+          "New M\xE9xico,NE",
+          'good line',
+          "New M\xE9xico,SF"
+        ]
+        input     = StringIO.new(bad_lines.join("\n"))
+        lines     = []
+        IOStreams::Line::Reader.open(input) do |io|
+          assert_equal false, io.strip_non_printable
+          assert_raises ArgumentError do
+            io.each { |line| lines << line }
+          end
+        end
+      end
+
+      it 'strips invalid characters' do
+        bad_lines   = [
+          "New M\xE9xico,NE",
+          'good line',
+          "New M\xE9xico,SF"
+        ]
+        fixed_lines = bad_lines.collect { |line| line.force_encoding('BINARY').gsub(/[^[:print:]|\r|\n]/, '') }
+        input       = StringIO.new(bad_lines.join("\n"))
+        lines       = []
+        IOStreams::Line::Reader.open(input, strip_non_printable: true) do |io|
+          assert_equal true, io.strip_non_printable
+          io.each { |line| lines << line }
+        end
+        assert_equal fixed_lines, lines
+      end
+    end
+
+    describe '#each' do
+      it 'each_line file' do
+        lines = []
+        IOStreams::Line::Reader.open(file_name) do |io|
+          io.each { |line| lines << line }
+        end
+        assert_equal data, lines
+      end
+
+      it 'each_line stream' do
+        lines = []
+        File.open(file_name) do |file|
+          IOStreams::Line::Reader.open(file) do |io|
+            io.each { |line| lines << line }
+          end
+        end
+        assert_equal data, lines
+      end
+
+      ["\r\n", "\n\r", "\n", "\r"].each do |delimiter|
+        it "autodetect delimiter: #{delimiter.inspect}" do
+          lines  = []
+          stream = StringIO.new(data.join(delimiter))
+          IOStreams::Line::Reader.open(stream, buffer_size: 15) do |io|
+            io.each { |line| lines << line }
+          end
+          assert_equal data, lines
+        end
+      end
+
+      ['@', 'BLAH'].each do |delimiter|
+        it "reads delimited #{delimiter.inspect}" do
+          lines  = []
+          stream = StringIO.new(data.join(delimiter))
+          IOStreams::Line::Reader.open(stream, buffer_size: 15, delimiter: delimiter) do |io|
+            io.each { |line| lines << line }
+          end
+          assert_equal data, lines
+        end
+      end
+
+      it 'reads binary delimited' do
+        delimiter = "\x01"
+        lines     = []
+        stream    = StringIO.new(data.join(delimiter))
+        IOStreams::Line::Reader.open(stream, buffer_size: 15, delimiter: delimiter, encoding: IOStreams::BINARY_ENCODING) do |io|
+          io.each { |line| lines << line }
+        end
+        assert_equal data, lines
+      end
+    end
+  end
+end

data/test/line_writer_test.rb

@@ -0,0 +1,50 @@
+require_relative 'test_helper'
+
+class DelimitedWriterTest < Minitest::Test
+  describe IOStreams::Line::Writer do
+    let :file_name do
+      File.join(File.dirname(__FILE__), 'files', 'text.txt')
+    end
+
+    let :raw do
+      File.read(file_name)
+    end
+
+    let :lines do
+      raw.lines.map(&:strip)
+    end
+
+    describe '#<<' do
+      it 'file' do
+        temp_file = Tempfile.new('rocket_job')
+        file_name = temp_file.to_path
+        IOStreams::Line::Writer.open(file_name) do |io|
+          lines.each { |line| io << line }
+        end
+        result = File.read(file_name)
+        assert_equal raw, result
+      end
+
+      it 'stream' do
+        io_string = StringIO.new
+        IOStreams::Line::Writer.open(io_string) do |io|
+          lines.each { |line| io << line }
+        end
+        assert_equal raw, io_string.string
+      end
+    end
+
+    describe '.write' do
+      it 'returns byte count' do
+        io_string = StringIO.new
+        count     = 0
+        IOStreams::Line::Writer.open(io_string) do |io|
+          lines.each { |line| count += io.write(line) }
+        end
+        assert_equal raw, io_string.string
+        assert_equal raw.size, count
+      end
+    end
+
+  end
+end

data/test/pgp_reader_test.rb

@@ -1,44 +1,44 @@
 require_relative 'test_helper'
 
-module Streams
-  class PgpReaderTest < Minitest::Test
-    describe IOStreams::Pgp::Reader do
-      before do
-        file_name  = File.join(File.dirname(__FILE__), 'files', 'text.txt')
-        @data      = File.read(file_name)
-        @temp_file = Tempfile.new('iostreams')
-        @file_name = @temp_file.to_path
-      end
+class PgpReaderTest < Minitest::Test
+  describe IOStreams::Pgp::Reader do
+    let :temp_file do
+      Tempfile.new('iostreams')
+    end
 
-      after do
-        @temp_file.delete if @temp_file
-      end
+    let :decrypted do
+      file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt')
+      File.read(file_name)
+    end
 
-      describe '.open' do
-        it 'reads encrypted file' do
-          IOStreams::Pgp::Writer.open(@file_name, recipient: 'receiver@example.org') do |io|
-            io.write(@data)
-          end
+    after do
+      temp_file.delete
+    end
 
-          result = IOStreams::Pgp::Reader.open(@file_name, passphrase: 'receiver_passphrase') { |file| file.read }
-          assert_equal @data, result
+    describe '.open' do
+      it 'reads encrypted file' do
+        IOStreams::Pgp::Writer.open(temp_file.path, recipient: 'receiver@example.org') do |io|
+          io.write(decrypted)
         end
 
-        it 'fails with bad passphrase' do
-          assert_raises IOStreams::Pgp::Failure do
-            IOStreams::Pgp::Reader.open(@file_name, passphrase: 'BAD') { |file| file.read }
-          end
-        end
+        result = IOStreams::Pgp::Reader.open(temp_file.path, passphrase: 'receiver_passphrase') { |file| file.read }
+        assert_equal decrypted, result
+      end
 
-        it 'fails with stream input' do
-          io = StringIO.new
-          assert_raises NotImplementedError do
-            IOStreams::Pgp::Reader.open(io, passphrase: 'BAD') { |file| file.read }
-          end
+      it 'fails with bad passphrase' do
+        assert_raises IOStreams::Pgp::Failure do
+          IOStreams::Pgp::Reader.open(temp_file.path, passphrase: 'BAD') { |file| file.read }
         end
+      end
 
+      it 'fails with stream input' do
+        io = StringIO.new
+        assert_raises NotImplementedError do
+          IOStreams::Pgp::Reader.open(io, passphrase: 'BAD') { |file| file.read }
+        end
       end
 
     end
+
   end
 end

data/test/pgp_test.rb

@@ -2,250 +2,204 @@ require_relative 'test_helper'
 
 #IOStreams::Pgp.logger = Logger.new(STDOUT)
 
-module Streams
-  class PgpTest < Minitest::Test
-    describe IOStreams::Pgp do
-      let :user_name do
-        'Joe Bloggs'
-      end
+class PgpTest < Minitest::Test
+  describe IOStreams::Pgp do
+    let :user_name do
+      'Joe Bloggs'
+    end
 
-      let :email do
-        'pgp_test@iostreams.net'
-      end
+    let :email do
+      'pgp_test@iostreams.net'
+    end
 
-      let :passphrase do
-        'hello'
-      end
+    let :passphrase do
+      'hello'
+    end
 
-      let :generated_key_id do
-        IOStreams::Pgp.generate_key(name: user_name, email: email, key_length: 1024, passphrase: passphrase)
-      end
+    let :generated_key_id do
+      IOStreams::Pgp.generate_key(name: user_name, email: email, key_length: 1024, passphrase: passphrase)
+    end
 
-      let :public_key do
-        generated_key_id
-        IOStreams::Pgp.export(email: email)
+    let :public_key do
+      generated_key_id
+      IOStreams::Pgp.export(email: email)
+    end
+
+    before do
+      # There is a timing issue with creating and then deleting keys.
+      # Call list_keys again to give GnuPGP time.
+      IOStreams::Pgp.list_keys(email: email, private: true)
+      IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
+      #ap "KEYS DELETED"
+      #ap IOStreams::Pgp.list_keys(email: email, private: true)
+    end
+
+    describe '.pgp_version' do
+      it 'returns pgp version' do
+        assert IOStreams::Pgp.pgp_version
       end
+    end
 
-      let :private_key do
-        generated_key_id
-        IOStreams::Pgp.export(email: email, private: true, passphrase: passphrase)
+    describe '.generate_key' do
+      it 'returns the key id' do
+        assert generated_key_id
       end
+    end
 
+    describe '.has_key?' do
       before do
-        #ap IOStreams::Pgp.list_keys(email: email, private: true)
-        IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
-        #ap "KEYS DELETED"
-        #ap IOStreams::Pgp.list_keys(email: email, private: true)
+        generated_key_id
+        # There is a timing issue with creating and then immediately using keys.
+        # Call list_keys again to give GnuPGP time.
+        IOStreams::Pgp.list_keys(email: email)
       end
 
-      describe '.pgp_version' do
-        it 'returns pgp version' do
-          assert IOStreams::Pgp.pgp_version
-        end
+      it 'confirms public key' do
+        assert IOStreams::Pgp.has_key?(key_id: generated_key_id)
       end
 
-      describe '.generate_key' do
-        it 'returns the key id' do
-          assert generated_key_id
-        end
+      it 'confirms private key' do
+        assert IOStreams::Pgp.has_key?(key_id: generated_key_id, private: true)
       end
+    end
 
-      describe '.has_key?' do
-        before do
-          generated_key_id
-        end
+    describe '.delete_keys' do
+      it 'handles no keys' do
+        refute IOStreams::Pgp.delete_keys(email: 'random@iostreams.net', public: true, private: true)
+      end
 
-        it 'confirms public key' do
-          assert IOStreams::Pgp.has_key?(key_id: generated_key_id)
-        end
+      it 'deletes existing keys' do
+        generated_key_id
+        # There is a timing issue with creating and then deleting keys.
+        # Call list_keys again to give GnuPGP time.
+        IOStreams::Pgp.list_keys(email: email, private: true)
+        assert IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
+      end
 
-        it 'confirms private key' do
-          assert IOStreams::Pgp.has_key?(key_id: generated_key_id, private: true)
-        end
+      it 'deletes just the private key' do
+        generated_key_id
+        # There is a timing issue with creating and then deleting keys.
+        # Call list_keys again to give GnuPGP time.
+        IOStreams::Pgp.list_keys(email: email, private: true)
+        assert IOStreams::Pgp.delete_keys(email: email, public: false, private: true)
+        refute IOStreams::Pgp.has_key?(key_id: generated_key_id, private: true)
+        assert IOStreams::Pgp.has_key?(key_id: generated_key_id, private: false)
       end
+    end
 
-      describe '.delete_keys' do
-        it 'handles no keys' do
-          refute IOStreams::Pgp.delete_keys(email: 'random@iostreams.net', public: true, private: true)
-        end
+    describe '.export' do
+      before do
+        generated_key_id
+      end
 
-        it 'deletes existing keys' do
-          generated_key_id
-          assert IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
-        end
+      it 'exports public keys by email' do
+        assert ascii_keys = IOStreams::Pgp.export(email: email)
+        assert ascii_keys =~ /BEGIN PGP PUBLIC KEY BLOCK/, ascii_keys
+      end
 
-        it 'deletes just the private key' do
-          generated_key_id
-          assert IOStreams::Pgp.delete_keys(email: email, public: false, private: true)
-          refute IOStreams::Pgp.has_key?(key_id: generated_key_id, private: true)
-          assert IOStreams::Pgp.has_key?(key_id: generated_key_id, private: false)
-        end
+      it 'exports public keys as binary' do
+        assert keys = IOStreams::Pgp.export(email: email, ascii: false)
+        refute keys =~ /BEGIN PGP (PUBLIC|PRIVATE) KEY BLOCK/, keys
       end
+    end
 
-      describe '.export' do
-        before do
-          generated_key_id
-        end
+    describe '.list_keys' do
+      before do
+        generated_key_id
+        # There is a timing issue with creating and then immediately using keys.
+        # Call list_keys again to give GnuPGP time.
+        IOStreams::Pgp.list_keys(email: email)
+      end
 
-        it 'exports public keys by email' do
-          assert ascii_keys = IOStreams::Pgp.export(email: email)
-          assert ascii_keys =~ /BEGIN PGP PUBLIC KEY BLOCK/, ascii_keys
+      it 'lists public keys' do
+        assert keys = IOStreams::Pgp.list_keys(email: email)
+        assert_equal 1, keys.size
+        assert key = keys.first
+
+        assert_equal Date.today, key[:date]
+        assert_equal email, key[:email]
+        assert_includes key[:key_id], generated_key_id
+        assert_equal 1024, key[:key_length]
+        assert_includes ['R', 'rsa'], key[:key_type]
+        assert_equal user_name, key[:name]
+        refute key[:private], key
+        ver   = IOStreams::Pgp.pgp_version
+        maint = ver.split('.').last.to_i
+        if (ver.to_f >= 2) && (maint >= 30)
+          assert_equal 'ultimate', key[:trust]
         end
+      end
 
-        it 'exports private keys by email' do
-          assert ascii_keys = IOStreams::Pgp.export(email: email, private: true, passphrase: passphrase)
-          assert ascii_keys =~ /BEGIN PGP PRIVATE KEY BLOCK/, ascii_keys
-        end
+      it 'lists private keys' do
+        assert keys = IOStreams::Pgp.list_keys(email: email, private: true)
+        assert_equal 1, keys.size
+        assert key = keys.first
+
+        assert_equal Date.today, key[:date]
+        assert_equal email, key[:email]
+        assert_includes key[:key_id], generated_key_id
+        assert_equal 1024, key[:key_length]
+        assert_includes ['R', 'rsa'], key[:key_type]
+        assert_equal user_name, key[:name]
+        assert key[:private], key
+      end
+    end
 
-        it 'exports public keys as binary' do
-          assert keys = IOStreams::Pgp.export(email: email, ascii: false)
-          refute keys =~ /BEGIN PGP (PUBLIC|PRIVATE) KEY BLOCK/, keys
-        end
+    describe '.key_info' do
+      it 'extracts public key info' do
+        assert keys = IOStreams::Pgp.key_info(key: public_key)
+        assert_equal 1, keys.size
+        assert key = keys.first
+
+        assert_equal Date.today, key[:date]
+        assert_equal email, key[:email]
+        assert_includes key[:key_id], generated_key_id
+        assert_equal 1024, key[:key_length]
+        assert_includes ['R', 'rsa'], key[:key_type]
+        assert_equal user_name, key[:name]
+        refute key[:private], key
+        refute key.key?(:trust)
+      end
+    end
 
-        it 'exports private keys as binary' do
-          assert keys = IOStreams::Pgp.export(email: email, ascii: false, private: true, passphrase: passphrase)
-          refute keys =~ /BEGIN PGP (PUBLIC|PRIVATE) KEY BLOCK/, keys
-        end
+    describe '.import' do
+      it 'handle duplicate public key' do
+        generated_key_id
+        assert_equal [], IOStreams::Pgp.import(key: public_key)
       end
 
-      describe '.list_keys' do
+      describe 'without keys' do
         before do
-          generated_key_id
+          @public_key = public_key
+          # There is a timing issue with creating and then deleting keys.
+          # Call list_keys again to give GnuPGP time.
+          IOStreams::Pgp.list_keys(email: email, private: true)
+          IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
         end
 
-        it 'lists public keys' do
-          assert keys = IOStreams::Pgp.list_keys(email: email)
+        it 'imports ascii public key' do
+          assert keys = IOStreams::Pgp.import(key: @public_key)
           assert_equal 1, keys.size
           assert key = keys.first
 
-          assert_equal Date.today, key[:date]
           assert_equal email, key[:email]
-          assert_includes key[:key_id], generated_key_id
-          assert_equal 1024, key[:key_length]
-          assert_includes ['R', 'rsa'], key[:key_type]
+          assert_equal generated_key_id, key[:key_id]
           assert_equal user_name, key[:name]
           refute key[:private], key
-          ver = IOStreams::Pgp.pgp_version
-          maint = ver.split('.').last.to_i
-          if (ver.to_f >= 2) && (maint >= 30)
-            assert_equal 'ultimate', key[:trust]
-          end
         end
 
-        it 'lists private keys' do
-          assert keys = IOStreams::Pgp.list_keys(email: email, private: true)
+        it 'imports binary public key' do
+          assert keys = IOStreams::Pgp.import(key: @public_key)
           assert_equal 1, keys.size
           assert key = keys.first
 
-          assert_equal Date.today, key[:date]
           assert_equal email, key[:email]
-          assert_includes key[:key_id], generated_key_id
-          assert_equal 1024, key[:key_length]
-          assert_includes ['R', 'rsa'], key[:key_type]
-          assert_equal user_name, key[:name]
-          assert key[:private], key
-        end
-      end
-
-      describe '.key_info' do
-        it 'extracts public key info' do
-          assert keys = IOStreams::Pgp.key_info(key: public_key)
-          assert_equal 1, keys.size
-          assert key = keys.first
-
-          assert_equal Date.today, key[:date]
-          assert_equal email, key[:email]
-          assert_includes key[:key_id], generated_key_id
-          assert_equal 1024, key[:key_length]
-          assert_includes ['R', 'rsa'], key[:key_type]
+          assert_equal generated_key_id, key[:key_id]
           assert_equal user_name, key[:name]
           refute key[:private], key
-          refute key.key?(:trust)
-        end
-
-        it 'extracts private key info' do
-          skip 'GnuPG v2.1 and above does not allow batch inspection of private keys' if IOStreams::Pgp.pgp_version.to_f >= 2.1
-          assert keys = IOStreams::Pgp.key_info(key: private_key)
-          assert_equal 1, keys.size
-          assert key = keys.first
-
-          assert_equal Date.today, key[:date]
-          assert_equal email, key[:email]
-          assert_includes key[:key_id], generated_key_id
-          assert_equal 1024, key[:key_length]
-          assert_equal 'R', key[:key_type]
-          assert_equal user_name, key[:name]
-          assert key[:private], key
-          refute key.key?(:trust)
         end
       end
-
-      describe '.import' do
-        it 'handle duplicate public key' do
-          generated_key_id
-          assert_equal [], IOStreams::Pgp.import(key: public_key)
-        end
-
-        it 'handle duplicate private key' do
-          generated_key_id
-          assert_equal [], IOStreams::Pgp.import(key: private_key)
-        end
-
-        describe 'without keys' do
-          before do
-            @public_key  = public_key
-            @private_key = private_key
-            IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
-          end
-
-          it 'imports ascii public key' do
-            assert keys = IOStreams::Pgp.import(key: @public_key)
-            assert_equal 1, keys.size
-            assert key = keys.first
-
-            assert_equal email, key[:email]
-            assert_equal generated_key_id, key[:key_id]
-            assert_equal user_name, key[:name]
-            refute key[:private], key
-          end
-
-          it 'imports ascii private key' do
-            skip 'GnuPG v2.1 and above does not allow batch import of private keys' if IOStreams::Pgp.pgp_version.to_f >= 2.1
-            assert keys = IOStreams::Pgp.import(key: @private_key)
-            assert_equal 1, keys.size
-            assert key = keys.first
-
-            assert_equal email, key[:email]
-            assert_equal generated_key_id, key[:key_id]
-            assert_equal user_name, key[:name]
-            assert key[:private], key
-          end
-
-          it 'imports binary public key' do
-            assert keys = IOStreams::Pgp.import(key: @public_key)
-            assert_equal 1, keys.size
-            assert key = keys.first
-
-            assert_equal email, key[:email]
-            assert_equal generated_key_id, key[:key_id]
-            assert_equal user_name, key[:name]
-            refute key[:private], key
-          end
-
-          it 'imports binary private key' do
-            skip 'GnuPG v2.1 and above does not allow batch import of private keys' if IOStreams::Pgp.pgp_version.to_f >= 2.1
-            assert keys = IOStreams::Pgp.import(key: @private_key)
-            assert_equal 1, keys.size
-            assert key = keys.first
-
-            assert_equal email, key[:email]
-            assert_equal generated_key_id, key[:key_id]
-            assert_equal user_name, key[:name]
-            assert key[:private], key
-          end
-        end
-      end
-
     end
+
   end
 end