iostreams 1.1.0 → 1.1.1

data/test/paths/sftp_test.rb

@@ -1,4 +1,4 @@
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 module Paths
   class SFTPTest < Minitest::Test
@@ -17,13 +17,13 @@ module Paths
 
       let(:url) { File.join("sftp://", host_name, ftp_dir) }
 
-      let(:file_name) { File.join(File.dirname(__FILE__), '..', 'files', 'text file.txt') }
+      let(:file_name) { File.join(File.dirname(__FILE__), "..", "files", "text file.txt") }
       let(:raw) { File.read(file_name) }
 
       let(:root_path) { IOStreams::Paths::SFTP.new(url, username: username, password: password) }
 
       let :existing_path do
-        path = root_path.join('test.txt')
+        path = root_path.join("test.txt")
         path.write(raw)
         path
       end
@@ -40,55 +40,55 @@ module Paths
         root_path.join("writer_test.txt")
       end
 
-      describe '#reader' do
-        it 'reads' do
-          assert_equal raw, existing_path.reader { |io| io.read }
+      describe "#reader" do
+        it "reads" do
+          assert_equal raw, existing_path.reader(&:read)
         end
 
-        it 'fails when the file does not exist' do
+        it "fails when the file does not exist" do
           assert_raises IOStreams::Errors::CommunicationsFailure do
             missing_file_path.read
           end
         end
 
-        it 'fails when the directory does not exist' do
+        it "fails when the directory does not exist" do
           assert_raises IOStreams::Errors::CommunicationsFailure do
             missing_path.read
           end
         end
       end
 
-      describe '#writer' do
-        it 'writes' do
+      describe "#writer" do
+        it "writes" do
           assert_equal raw.size, write_path.writer { |io| io.write(raw) }
           assert_equal raw, write_path.read
         end
 
-        it 'fails when the directory does not exist' do
+        it "fails when the directory does not exist" do
           assert_raises IOStreams::Errors::CommunicationsFailure do
             missing_path.write("Bad path")
           end
         end
 
-        describe 'use identity file instead of password' do
+        describe "use identity file instead of password" do
           let :root_path do
-            IOStreams::Paths::SFTP.new(url, username: identity_username, ssh_options: {'IdentityFile' => ENV["SFTP_IDENTITY_FILE"]})
+            IOStreams::Paths::SFTP.new(url, username: identity_username, ssh_options: {"IdentityFile" => ENV["SFTP_IDENTITY_FILE"]})
           end
 
-          it 'writes' do
+          it "writes" do
             skip "No identity file env var set: SFTP_IDENTITY_FILE" unless ENV["SFTP_IDENTITY_FILE"]
             assert_equal raw.size, write_path.writer { |io| io.write(raw) }
             assert_equal raw, write_path.read
           end
         end
 
-        describe 'use identity key instead of password' do
+        describe "use identity key instead of password" do
           let :root_path do
-            key = File.open(ENV["SFTP_IDENTITY_FILE"], 'rb', &:read)
-            IOStreams::Paths::SFTP.new(url, username: identity_username, ssh_options: {'IdentityKey' => key})
+            key = File.open(ENV["SFTP_IDENTITY_FILE"], "rb", &:read)
+            IOStreams::Paths::SFTP.new(url, username: identity_username, ssh_options: {"IdentityKey" => key})
           end
 
-          it 'writes' do
+          it "writes" do
             skip "No identity file env var set: SFTP_IDENTITY_FILE" unless ENV["SFTP_IDENTITY_FILE"]
             assert_equal raw.size, write_path.writer { |io| io.write(raw) }
             assert_equal raw, write_path.read

data/test/pgp_reader_test.rb

@@ -1,13 +1,13 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class PgpReaderTest < Minitest::Test
   describe IOStreams::Pgp::Reader do
     let :temp_file do
-      Tempfile.new('iostreams')
+      Tempfile.new("iostreams")
     end
 
     let :decrypted do
-      file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt')
+      file_name = File.join(File.dirname(__FILE__), "files", "text.txt")
       File.read(file_name)
     end
 
@@ -15,34 +15,32 @@ class PgpReaderTest < Minitest::Test
       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|
+    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') { |file| file.read }
+        result = IOStreams::Pgp::Reader.file(temp_file.path, passphrase: "receiver_passphrase", &:read)
         assert_equal decrypted, result
       end
 
-      it 'fails with bad passphrase' do
+      it "fails with bad passphrase" do
         assert_raises IOStreams::Pgp::Failure do
-          IOStreams::Pgp::Reader.file(temp_file.path, passphrase: 'BAD') { |file| file.read }
+          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|
+      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)
+        result = IOStreams::Pgp::Reader.stream(io, passphrase: "receiver_passphrase", &:read)
         assert_equal decrypted, result
       end
-
     end
-
   end
 end

data/test/pgp_test.rb

@@ -1,19 +1,21 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
-#IOStreams::Pgp.logger = Logger.new(STDOUT)
+# 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'
+      "Joe Bloggs"
     end
 
     let :email do
-      'pgp_test@iostreams.net'
+      "pgp_test@iostreams.net"
     end
 
     let :passphrase do
-      'hello'
+      "hello"
     end
 
     let :generated_key_id do
@@ -30,23 +32,23 @@ class PgpTest < Minitest::Test
       # 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)
+      # ap "KEYS DELETED"
+      # ap IOStreams::Pgp.list_keys(email: email, private: true)
     end
 
-    describe '.pgp_version' do
-      it 'returns pgp version' do
+    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
+    describe ".generate_key" do
+      it "returns the key id" do
         assert generated_key_id
       end
     end
 
-    describe '.has_key?' do
+    describe ".key?" do
       before do
         generated_key_id
         # There is a timing issue with creating and then immediately using keys.
@@ -54,21 +56,21 @@ class PgpTest < Minitest::Test
         IOStreams::Pgp.list_keys(email: email)
       end
 
-      it 'confirms public key' do
-        assert IOStreams::Pgp.has_key?(key_id: generated_key_id)
+      it "confirms public key" do
+        assert IOStreams::Pgp.key?(key_id: generated_key_id)
       end
 
-      it 'confirms private key' do
-        assert IOStreams::Pgp.has_key?(key_id: generated_key_id, private: true)
+      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)
+    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' do
+      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.
@@ -76,34 +78,34 @@ class PgpTest < Minitest::Test
         assert IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
       end
 
-      it 'deletes just the private key' do
+      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)
+        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
+    describe ".export" do
       before do
         generated_key_id
       end
 
-      it 'exports public keys by email' do
+      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
+      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
+    describe ".list_keys" do
       before do
         generated_key_id
         # There is a timing issue with creating and then immediately using keys.
@@ -111,7 +113,7 @@ class PgpTest < Minitest::Test
         IOStreams::Pgp.list_keys(email: email)
       end
 
-      it 'lists public keys' do
+      it "lists public keys" do
         assert keys = IOStreams::Pgp.list_keys(email: email)
         assert_equal 1, keys.size
         assert key = keys.first
@@ -120,17 +122,15 @@ class PgpTest < Minitest::Test
         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_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
-        if (ver.to_f >= 2) && (maint >= 30)
-          assert_equal 'ultimate', key[:trust]
-        end
+        maint = ver.split(".").last.to_i
+        assert_equal "ultimate", key[:trust] if (ver.to_f >= 2) && (maint >= 30)
       end
 
-      it 'lists private keys' do
+      it "lists private keys" do
         assert keys = IOStreams::Pgp.list_keys(email: email, private: true)
         assert_equal 1, keys.size
         assert key = keys.first
@@ -139,14 +139,14 @@ class PgpTest < Minitest::Test
         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_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
+    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
@@ -155,20 +155,20 @@ class PgpTest < Minitest::Test
         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_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
+    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
+      describe "without keys" do
         before do
           @public_key = public_key
           # There is a timing issue with creating and then deleting keys.
@@ -177,7 +177,7 @@ class PgpTest < Minitest::Test
           IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
         end
 
-        it 'imports ascii public key' do
+        it "imports ascii public key" do
           assert keys = IOStreams::Pgp.import(key: @public_key)
           assert_equal 1, keys.size
           assert key = keys.first
@@ -188,7 +188,7 @@ class PgpTest < Minitest::Test
           refute key[:private], key
         end
 
-        it 'imports binary public key' do
+        it "imports binary public key" do
           assert keys = IOStreams::Pgp.import(key: @public_key)
           assert_equal 1, keys.size
           assert key = keys.first
@@ -200,6 +200,5 @@ class PgpTest < Minitest::Test
         end
       end
     end
-
   end
 end

data/test/pgp_writer_test.rb

@@ -1,9 +1,9 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class PgpWriterTest < Minitest::Test
   describe IOStreams::Pgp::Writer do
     let :temp_file do
-      Tempfile.new('iostreams')
+      Tempfile.new("iostreams")
     end
 
     let :file_name do
@@ -11,7 +11,7 @@ class PgpWriterTest < Minitest::Test
     end
 
     let :decrypted do
-      file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt')
+      file_name = File.join(File.dirname(__FILE__), "files", "text.txt")
       File.read(file_name)
     end
 
@@ -19,51 +19,51 @@ class PgpWriterTest < Minitest::Test
       temp_file.delete
     end
 
-    describe '.file' do
-      it 'writes encrypted text file' do
-        IOStreams::Pgp::Writer.file(file_name, recipient: 'receiver@example.org') do |io|
+    describe ".file" do
+      it "writes encrypted text file" do
+        IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org") do |io|
           io.write(decrypted)
         end
 
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: 'receiver_passphrase', &:read)
+        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') { |file| file.read }
+      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|
-          IOStreams::Pgp::Writer.file(file_name, recipient: 'receiver@example.org') do |output|
+        File.open(binary_file_name, "rb") do |input|
+          IOStreams::Pgp::Writer.file(file_name, recipient: "receiver@example.org") do |output|
             IO.copy_stream(input, output)
           end
         end
 
-        result = IOStreams::Pgp::Reader.file(file_name, passphrase: 'receiver_passphrase', &:read)
+        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|
+      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)
+        result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver_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
+      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|
+          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
+      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|
+          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
@@ -72,25 +72,24 @@ class PgpWriterTest < Minitest::Test
         end
       end
 
-      it 'fails with bad signer' do
+      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|
+          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)
-        IOStreams::Pgp::Writer.stream(io_string, recipient: 'receiver@example.org', signer: 'sender@example.org', signer_passphrase: 'sender_passphrase') do |io|
+      it "writes to a stream" 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)
+        result = IOStreams::Pgp::Reader.stream(io, passphrase: "receiver_passphrase", &:read)
         assert_equal decrypted, result
       end
-
     end
   end
 end