iostreams 1.10.3 → 2.0.0

data/test/pgp_reader_test.rb

@@ -1,46 +0,0 @@
-require_relative "test_helper"
-
-class PgpReaderTest < Minitest::Test
-  describe IOStreams::Pgp::Reader do
-    let :temp_file do
-      Tempfile.new("iostreams")
-    end
-
-    let :decrypted do
-      file_name = File.join(File.dirname(__FILE__), "files", "text.txt")
-      File.read(file_name)
-    end
-
-    after do
-      temp_file.delete
-    end
-
-    describe ".file" do
-      it "reads encrypted file" do
-        IOStreams::Pgp::Writer.file(temp_file.path, recipient: "receiver@example.org") do |io|
-          io.write(decrypted)
-        end
-
-        result = IOStreams::Pgp::Reader.file(temp_file.path, passphrase: "receiver_passphrase", &:read)
-        assert_equal decrypted, result
-      end
-
-      it "fails with bad passphrase" do
-        assert_raises IOStreams::Pgp::Failure do
-          IOStreams::Pgp::Reader.file(temp_file.path, passphrase: "BAD", &:read)
-        end
-      end
-
-      it "streams input" do
-        io_string = StringIO.new("".b)
-        IOStreams::Pgp::Writer.stream(io_string, recipient: "receiver@example.org", signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
-          io.write(decrypted)
-        end
-
-        io     = StringIO.new(io_string.string)
-        result = IOStreams::Pgp::Reader.stream(io, passphrase: "receiver_passphrase", &:read)
-        assert_equal decrypted, result
-      end
-    end
-  end
-end

data/test/pgp_test.rb

@@ -1,254 +0,0 @@
-require_relative "test_helper"
-
-# Turn on logging if experiencing issues with new versions of gpg
-# require "logger"
-# IOStreams::Pgp.logger = Logger.new(STDOUT)
-
-class PgpTest < Minitest::Test
-  describe IOStreams::Pgp do
-    let :user_name do
-      "Joe Bloggs"
-    end
-
-    let :email do
-      "pgp_test@iostreams.net"
-    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 :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
-
-    describe ".generate_key" do
-      it "returns the key id" do
-        assert generated_key_id
-      end
-    end
-
-    describe ".key?" 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 "confirms public key" do
-        assert IOStreams::Pgp.key?(key_id: generated_key_id)
-      end
-
-      it "confirms private key" do
-        assert IOStreams::Pgp.key?(key_id: generated_key_id, private: true)
-      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
-
-      it "deletes existing keys with specified email" 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 "deletes existing keys with specified key_id" 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(key_id: generated_key_id, private: true)
-        assert IOStreams::Pgp.delete_keys(key_id: generated_key_id, public: true, private: true)
-      end
-
-      it "deletes just the private key with specified email" 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.key?(key_id: generated_key_id, private: true)
-        assert IOStreams::Pgp.key?(key_id: generated_key_id, private: false)
-      end
-
-      it "deletes just the private key with specified key_id" 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(key_id: generated_key_id, private: true)
-        assert IOStreams::Pgp.delete_keys(key_id: generated_key_id, public: false, private: true)
-        refute IOStreams::Pgp.key?(key_id: generated_key_id, private: true)
-        assert IOStreams::Pgp.key?(key_id: generated_key_id, private: false)
-      end
-    end
-
-    describe ".export" do
-      before do
-        generated_key_id
-      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 "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 ".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 "lists public keys for email" 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 %w[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
-        assert_equal "ultimate", key[:trust] if (ver.to_f >= 2) && (maint >= 30)
-      end
-
-      it "lists public keys for key_id" do
-        assert keys = IOStreams::Pgp.list_keys(key_id: generated_key_id)
-        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 %w[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
-        assert_equal "ultimate", key[:trust] if (ver.to_f >= 2) && (maint >= 30)
-      end
-
-      it "lists private keys for email" 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 %w[R rsa], key[:key_type]
-        assert_equal user_name, key[:name]
-        assert key[:private], key
-      end
-
-      it "lists private keys for key_id" do
-        assert keys = IOStreams::Pgp.list_keys(key_id: generated_key_id, 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 %w[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 %w[R rsa], key[:key_type]
-        assert_equal user_name, key[:name]
-        refute 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
-
-      describe "without keys" do
-        before do
-          @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 "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 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
-      end
-    end
-  end
-end

data/test/pgp_writer_test.rb

@@ -1,130 +0,0 @@
-require_relative "test_helper"
-
-class PgpWriterTest < Minitest::Test
-  describe IOStreams::Pgp::Writer do
-    let :temp_file do
-      Tempfile.new("iostreams")
-    end
-
-    let :file_name do
-      temp_file.path
-    end
-
-    let :decrypted do
-      file_name = File.join(File.dirname(__FILE__), "files", "text.txt")
-      File.read(file_name)
-    end
-
-    after do
-      temp_file.delete
-    end
-
-    describe ".file" do
-      it "writes encrypted text file" do
-        result =
-          IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org") do |io|
-            io.write(decrypted)
-            53534
-          end
-        assert_equal 53534, result
-
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver_passphrase", &:read)
-        assert_equal decrypted, result
-      end
-
-      it "writes encrypted binary file" do
-        binary_file_name = File.join(File.dirname(__FILE__), "files", "spreadsheet.xlsx")
-        binary_data      = File.open(binary_file_name, "rb", &:read)
-
-        File.open(binary_file_name, "rb") do |input|
-          result =
-            IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org") do |output|
-              IO.copy_stream(input, output)
-              53534
-            end
-          assert_equal 53534, result
-        end
-
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver_passphrase", &:read)
-        assert_equal binary_data, result
-      end
-
-      it "writes and signs encrypted file" do
-        IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org", signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
-          io.write(decrypted)
-        end
-
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver_passphrase", &:read)
-        assert_equal decrypted, result
-      end
-
-      it "supports multiple recipients" do
-        IOStreams::Pgp::Writer.file(file_name, recipient: %w[receiver@example.org receiver2@example.org], signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
-          io.write(decrypted)
-        end
-
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver_passphrase", &:read)
-        assert_equal decrypted, result
-
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver2_passphrase", &:read)
-        assert_equal decrypted, result
-      end
-
-      it "encrypts for recipient and audit recipient" do
-        IOStreams::Pgp::Writer.stub(:audit_recipient, "receiver2@example.org") do
-          IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org", signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
-            io.write(decrypted)
-          end
-        end
-
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver_passphrase", &:read)
-        assert_equal decrypted, result
-
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver2_passphrase", &:read)
-        assert_equal decrypted, result
-      end
-
-      it "fails with bad signer passphrase" do
-        skip "GnuPG v2.1 and above passes when it should not" if IOStreams::Pgp.pgp_version.to_f >= 2.1
-        assert_raises IOStreams::Pgp::Failure do
-          IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org", signer: "sender@example.org", signer_passphrase: "BAD") do |io|
-            io.write(decrypted)
-          end
-        end
-      end
-
-      it "fails with bad recipient" do
-        assert_raises IOStreams::Pgp::Failure do
-          IOStreams::Pgp::Writer.file(file_name, recipient: "BAD@example.org", signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
-            io.write(decrypted)
-            # Allow process to terminate
-            sleep 1
-            io.write(decrypted)
-          end
-        end
-      end
-
-      it "fails with bad signer" do
-        assert_raises IOStreams::Pgp::Failure do
-          IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org", signer: "BAD@example.org", signer_passphrase: "sender_passphrase") do |io|
-            io.write(decrypted)
-          end
-        end
-      end
-
-      it "writes to a stream" do
-        io_string = StringIO.new("".b)
-        result    =
-          IOStreams::Pgp::Writer.stream(io_string, recipient: "receiver@example.org", signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
-            io.write(decrypted)
-            53534
-          end
-        assert_equal 53534, result
-
-        io     = StringIO.new(io_string.string)
-        result = IOStreams::Pgp::Reader.stream(io, passphrase: "receiver_passphrase", &:read)
-        assert_equal decrypted, result
-      end
-    end
-  end
-end

data/test/record_reader_test.rb

@@ -1,60 +0,0 @@
-require_relative "test_helper"
-
-class RecordReaderTest < Minitest::Test
-  describe IOStreams::Record::Reader do
-    let :file_name do
-      File.join(File.dirname(__FILE__), "files", "test.csv")
-    end
-
-    let :json_file_name do
-      File.join(File.dirname(__FILE__), "files", "test.json")
-    end
-
-    let :csv_rows do
-      CSV.read(file_name)
-    end
-
-    let :expected do
-      rows   = csv_rows.dup
-      header = rows.shift
-      rows.collect { |row| header.zip(row).to_h }
-    end
-
-    describe "#each" do
-      it "csv file" do
-        records = []
-        IOStreams::Record::Reader.file(file_name, cleanse_header: false) do |io|
-          io.each { |row| records << row }
-        end
-        assert_equal expected, records
-      end
-
-      it "json file" do
-        records = []
-        IOStreams::Record::Reader.file(json_file_name, cleanse_header: false, format: :json) do |input|
-          input.each { |row| records << row }
-        end
-        assert_equal expected, records
-      end
-
-      it "stream" do
-        rows = []
-        IOStreams::Line::Reader.file(file_name) do |file|
-          IOStreams::Record::Reader.stream(file, cleanse_header: false) do |io|
-            io.each { |row| rows << row }
-          end
-        end
-        assert_equal expected, rows
-      end
-    end
-
-    describe "#collect" do
-      it "json file" do
-        records = IOStreams::Record::Reader.file(json_file_name, format: :json) do |input|
-          input.collect { |record| record["state"] }
-        end
-        assert_equal expected.collect { |record| record["state"] }, records
-      end
-    end
-  end
-end

data/test/record_writer_test.rb

@@ -1,82 +0,0 @@
-require_relative "test_helper"
-require "csv"
-
-class RecordWriterTest < Minitest::Test
-  describe IOStreams::Record::Writer do
-    let :csv_file_name do
-      File.join(File.dirname(__FILE__), "files", "test.csv")
-    end
-
-    let :json_file_name do
-      File.join(File.dirname(__FILE__), "files", "test.json")
-    end
-
-    let :raw_csv_data do
-      File.read(csv_file_name)
-    end
-
-    let :raw_json_data do
-      File.read(json_file_name)
-    end
-
-    let :csv_rows do
-      CSV.read(csv_file_name)
-    end
-
-    let :inputs do
-      rows   = csv_rows.dup
-      header = rows.shift
-      rows.collect { |row| header.zip(row).to_h }
-    end
-
-    let :temp_file do
-      Tempfile.new("iostreams")
-    end
-
-    let :file_name do
-      temp_file.path
-    end
-
-    after do
-      temp_file.delete
-    end
-
-    describe "#<<" do
-      it "file" do
-        result =
-          IOStreams::Record::Writer.file(file_name) do |io|
-            inputs.each { |hash| io << hash }
-            53534
-          end
-        assert_equal 53534, result
-        result = File.read(file_name)
-        assert_equal raw_csv_data, result
-      end
-
-      it "json file" do
-        result =
-          IOStreams::Record::Writer.file(file_name, file_name: "abc.json") do |io|
-            inputs.each { |hash| io << hash }
-            53534
-          end
-        assert_equal 53534, result
-
-        result = File.read(file_name)
-        assert_equal raw_json_data, result
-      end
-
-      it "stream" do
-        io_string = StringIO.new
-        result    =
-          IOStreams::Line::Writer.stream(io_string) do |io|
-            IOStreams::Record::Writer.stream(io) do |stream|
-              inputs.each { |row| stream << row }
-              53534
-            end
-          end
-        assert_equal 53534, result
-        assert_equal raw_csv_data, io_string.string
-      end
-    end
-  end
-end

data/test/row_reader_test.rb

@@ -1,35 +0,0 @@
-require_relative "test_helper"
-
-class RowReaderTest < Minitest::Test
-  describe IOStreams::Row::Reader do
-    let :file_name do
-      File.join(File.dirname(__FILE__), "files", "test.csv")
-    end
-
-    let :expected do
-      CSV.read(file_name)
-    end
-
-    describe "#each" do
-      it "file" do
-        rows  = []
-        count = IOStreams::Row::Reader.file(file_name) do |io|
-          io.each { |row| rows << row }
-        end
-        assert_equal expected, rows
-        assert_equal expected.size, count
-      end
-
-      it "stream" do
-        rows  = []
-        count = IOStreams::Line::Reader.file(file_name) do |file|
-          IOStreams::Row::Reader.stream(file) do |io|
-            io.each { |row| rows << row }
-          end
-        end
-        assert_equal expected, rows
-        assert_equal expected.size, count
-      end
-    end
-  end
-end

data/test/row_writer_test.rb

@@ -1,56 +0,0 @@
-require_relative "test_helper"
-require "csv"
-
-class RowWriterTest < Minitest::Test
-  describe IOStreams::Row::Writer do
-    let :csv_file_name do
-      File.join(File.dirname(__FILE__), "files", "test.csv")
-    end
-
-    let :raw_csv_data do
-      File.read(csv_file_name)
-    end
-
-    let :csv_rows do
-      CSV.read(csv_file_name)
-    end
-
-    let :temp_file do
-      Tempfile.new("iostreams")
-    end
-
-    let :file_name do
-      temp_file.path
-    end
-
-    after do
-      temp_file.delete
-    end
-
-    describe ".stream" do
-      it "file" do
-        result =
-          IOStreams::Row::Writer.file(file_name) do |io|
-            csv_rows.each { |array| io << array }
-            53534
-          end
-        assert_equal 53534, result
-        result = ::File.read(file_name)
-        assert_equal raw_csv_data, result
-      end
-
-      it "streams" do
-        io_string = StringIO.new
-        result    =
-          IOStreams::Line::Writer.stream(io_string) do |io|
-            IOStreams::Row::Writer.stream(io) do |stream|
-              csv_rows.each { |array| stream << array }
-              53534
-            end
-          end
-        assert_equal 53534, result
-        assert_equal raw_csv_data, io_string.string
-      end
-    end
-  end
-end