iostreams 1.2.1 → 1.4.0

data/test/paths/sftp_test.rb

@@ -42,7 +42,7 @@ module Paths
 
       describe "#reader" do
         it "reads" do
-          assert_equal raw, existing_path.reader(&:read)
+          assert_equal raw, existing_path.read
         end
 
         it "fails when the file does not exist" do
@@ -60,7 +60,7 @@ module Paths
 
       describe "#writer" do
         it "writes" do
-          assert_equal raw.size, write_path.writer { |io| io.write(raw) }
+          assert_equal(raw.size, write_path.writer { |io| io.write(raw) })
           assert_equal raw, write_path.read
         end
 
@@ -77,7 +77,7 @@ module Paths
 
           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.size, write_path.writer { |io| io.write(raw) })
             assert_equal raw, write_path.read
           end
         end
@@ -90,7 +90,7 @@ module Paths
 
           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.size, write_path.writer { |io| io.write(raw) })
             assert_equal raw, write_path.read
           end
         end

data/test/pgp_test.rb

@@ -70,7 +70,7 @@ class PgpTest < Minitest::Test
         refute IOStreams::Pgp.delete_keys(email: "random@iostreams.net", public: true, private: true)
       end
 
-      it "deletes existing keys" do
+      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.
@@ -78,7 +78,16 @@ 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 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.
@@ -87,6 +96,16 @@ class PgpTest < Minitest::Test
         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
@@ -113,7 +132,7 @@ class PgpTest < Minitest::Test
         IOStreams::Pgp.list_keys(email: email)
       end
 
-      it "lists public keys" do
+      it "lists public keys for email" do
         assert keys = IOStreams::Pgp.list_keys(email: email)
         assert_equal 1, keys.size
         assert key = keys.first
@@ -130,7 +149,24 @@ class PgpTest < Minitest::Test
         assert_equal "ultimate", key[:trust] if (ver.to_f >= 2) && (maint >= 30)
       end
 
-      it "lists private keys" do
+      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
@@ -143,6 +179,20 @@ class PgpTest < Minitest::Test
         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

data/test/pgp_writer_test.rb

@@ -53,9 +53,9 @@ class PgpWriterTest < Minitest::Test
       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
+        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

data/test/tabular_test.rb

@@ -138,33 +138,47 @@ class TabularTest < Minitest::Test
       describe ":fixed format" do
         let :tabular do
           layout = [
-            {key: "name", size: 23},
-            {key: "address", size: 40},
-            {key: "zip", size: 5}
+            {size: 23, key: :name},
+            {size: 40, key: :address},
+            {size: 2},
+            {size: 5, key: :zip, type: :integer},
+            {size: 8, key: :age, type: :integer},
+            {size: 10, key: :weight, type: :float, decimals: 2}
           ]
           IOStreams::Tabular.new(format: :fixed, format_options: {layout: layout})
         end
 
         it "parses to hash" do
-          assert hash = tabular.record_parse("Jack                   over there                              34618")
-          assert_equal({"name" => "Jack", "address" => "over there", "zip" => "34618"}, hash)
+          assert hash = tabular.record_parse("Jack                   over there                              XX34618012345670012345.01")
+          assert_equal({name: "Jack", address: "over there", zip: 34_618, age: 1_234_567, weight: 12_345.01}, hash)
         end
 
         it "parses short string" do
-          # TODO: Raise exception on lines that are too short?
-          assert hash = tabular.record_parse("Jack                   over th")
-          assert_equal({"name" => "Jack", "address" => "over th", "zip" => ""}, hash)
+          assert_raises IOStreams::Errors::InvalidLineLength do
+            tabular.record_parse("Jack                   over th")
+          end
         end
 
         it "parses longer string" do
-          # TODO: Raise exception on lines that are too long?
-          assert hash = tabular.record_parse("Jack                   over there                              34618........................................")
-          assert_equal({"name" => "Jack", "address" => "over there", "zip" => "34618"}, hash)
+          assert_raises IOStreams::Errors::InvalidLineLength do
+            tabular.record_parse("Jack                   over there                              XX34618012345670012345.01............")
+          end
+        end
+
+        it "parses zero values" do
+          assert hash = tabular.record_parse("                                                                 00000000000000000000000")
+          assert_equal({name: "", address: "", zip: 0, age: 0, weight: 0.0}, hash)
+        end
+
+        it "parses empty values" do
+          assert hash = tabular.record_parse("                                                               XX                       ")
+          assert_equal({name: "", address: "", zip: nil, age: nil, weight: nil}, hash)
         end
 
-        it "parses empty strings" do
-          assert hash = tabular.record_parse("                                                               34618")
-          assert_equal({"name" => "", "address" => "", "zip" => "34618"}, hash)
+        it "parses blank strings" do
+          skip "TODO: Part of tabular refactor to get this working"
+          assert hash = tabular.record_parse("                                                                                        ")
+          assert_equal({name: "", address: "", zip: nil, age: nil, weight: nil}, hash)
         end
 
         it "parses nil data as nil" do
@@ -224,31 +238,46 @@ class TabularTest < Minitest::Test
       describe ":fixed format" do
         let :tabular do
           layout = [
-            {key: "name", size: 23},
-            {key: "address", size: 40},
-            {key: "zip", size: 5}
+            {size: 23, key: :name},
+            {size: 40, key: :address},
+            {size: 2},
+            {size: 5, key: :zip, type: :integer},
+            {size: 8, key: :age, type: :integer},
+            {size: 10, key: :weight, type: :float, decimals: 2}
           ]
           IOStreams::Tabular.new(format: :fixed, format_options: {layout: layout})
         end
 
         it "renders fixed data" do
-          assert string = tabular.render({"name" => "Jack", "address" => "over there", "zip" => 34_618, "phone" => "5551231234"})
-          assert_equal "Jack                   over there                              34618", string
+          assert string = tabular.render(name: "Jack", address: "over there", zip: 34_618, weight: 123_456.789123, age: 21)
+          assert_equal "Jack                   over there                                34618000000210123456.79", string
         end
 
-        it "truncates long data" do
-          assert string = tabular.render({"name" => "Jack", "address" => "over there", "zip" => 3_461_832_653_653_265, "phone" => "5551231234"})
-          assert_equal "Jack                   over there                              34618", string
+        it "truncates long strings" do
+          assert string = tabular.render(name: "Jack ran up the beanstalk and when jack reached the top it was truncated", address: "over there", zip: 34_618)
+          assert_equal "Jack ran up the beanstaover there                                34618000000000000000.00", string
+        end
+
+        it "when integer is too large" do
+          assert_raises IOStreams::Errors::ValueTooLong do
+            tabular.render(zip: 3_461_832_653_653_265)
+          end
+        end
+
+        it "when float is too large" do
+          assert_raises IOStreams::Errors::ValueTooLong do
+            tabular.render(weight: 3_461_832_653_653_265.234)
+          end
         end
 
         it "renders nil as empty string" do
-          assert string = tabular.render("zip" => 3_461_832_653_653_265)
-          assert_equal "                                                               34618", string
+          assert string = tabular.render(zip: 34_618)
+          assert_equal "                                                                 34618000000000000000.00", string
         end
 
         it "renders boolean" do
-          assert string = tabular.render({"name" => true, "address" => false, "zip" => nil, "phone" => "5551231234"})
-          assert_equal "true                   false                                        ", string
+          assert string = tabular.render(name: true, address: false)
+          assert_equal "true                   false                                     00000000000000000000.00", string
         end
 
         it "renders no data as nil" do

data/test/test_helper.rb

@@ -4,7 +4,7 @@ require "yaml"
 require "minitest/autorun"
 require "minitest/reporters"
 require "iostreams"
-require "awesome_print"
+require "amazing_print"
 require "symmetric-encryption"
 
 # Since PGP libraries use UTC for Dates

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iostreams
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-19 00:00:00.000000000 Z
+date: 2020-09-04 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -130,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Input and Output streaming for Ruby.