symmetric-encryption 3.8.2 → 3.8.3

data/test/reader_test.rb

@@ -9,7 +9,7 @@ class ReaderTest < Minitest::Test
       @data                          = [
         "Hello World\n",
         "Keep this secret\n",
-        "And keep going even further and further..."
+        'And keep going even further and further...'
       ]
       @data_str                      = @data.inject('') { |sum, str| sum << str }
       @data_len                      = @data_str.length
@@ -19,7 +19,7 @@ class ReaderTest < Minitest::Test
 
       @data_encrypted_with_header = SymmetricEncryption::Cipher.build_header(
         @cipher.version,
-        compress = false,
+        false,
         @cipher.send(:iv),
         @cipher.send(:key),
         @cipher.cipher_name
@@ -59,7 +59,7 @@ class ReaderTest < Minitest::Test
           stream    = StringIO.new(@data_encrypted)
           i         = 0
           # Version 0 supplied if the file/stream does not have a header
-          decrypted = SymmetricEncryption::Reader.open(stream, version: 0) do |file|
+          SymmetricEncryption::Reader.open(stream, version: 0) do |file|
             file.each_line do |line|
               assert_equal @data[i], line
               i += 1
@@ -69,9 +69,8 @@ class ReaderTest < Minitest::Test
 
         it "#read(size)" do
           stream    = StringIO.new(@data_encrypted)
-          i         = 0
           # Version 0 supplied if the file/stream does not have a header
-          decrypted = SymmetricEncryption::Reader.open(stream, version: 0) do |file|
+          SymmetricEncryption::Reader.open(stream, version: 0) do |file|
             index = 0
             [0, 10, 5, 5000].each do |size|
               buf = file.read(size)
@@ -155,7 +154,7 @@ class ReaderTest < Minitest::Test
             end
           end
 
-          it ".open return Zlib::GzipReader when compressed" do
+          it '.open return Zlib::GzipReader when compressed' do
             file = SymmetricEncryption::Reader.open(@filename)
             #assert_equal (@header && (options[:compress]||false)), file.is_a?(Zlib::GzipReader)
             file.close
@@ -184,7 +183,7 @@ class ReaderTest < Minitest::Test
           end
 
           it "#each_line" do
-            decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
+            SymmetricEncryption::Reader.open(@filename) do |file|
               i = 0
               file.each_line do |line|
                 assert_equal @data[i], line
@@ -223,7 +222,7 @@ class ReaderTest < Minitest::Test
           end
 
           it "#gets(delim)" do
-            decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
+            SymmetricEncryption::Reader.open(@filename) do |file|
               i = 0
               while line = file.gets("\n")
                 assert_equal @data[i], line
@@ -234,9 +233,9 @@ class ReaderTest < Minitest::Test
           end
 
           it "#gets(delim,size)" do
-            decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
+            SymmetricEncryption::Reader.open(@filename) do |file|
               i = 0
-              while line = file.gets("\n", 128)
+              while file.gets("\n", 128)
                 i += 1
               end
               assert_equal (@data_size > 0 ? 3 : 0), i
@@ -247,7 +246,7 @@ class ReaderTest < Minitest::Test
       end
     end
 
-    describe "reading from files with previous keys" do
+    describe 'reading from files with previous keys' do
       before do
         @filename = '_test'
         # Create encrypted file with old encryption key
@@ -260,13 +259,13 @@ class ReaderTest < Minitest::Test
         File.delete(@filename) if File.exist?(@filename)
       end
 
-      it "decrypt from file in a single read" do
+      it 'decrypt from file in a single read' do
         decrypted = SymmetricEncryption::Reader.open(@filename) { |file| file.read }
         assert_equal @data_str, decrypted
       end
 
-      it "decrypt from file a line at a time" do
-        decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
+      it 'decrypt from file a line at a time' do
+        SymmetricEncryption::Reader.open(@filename) do |file|
           i = 0
           file.each_line do |line|
             assert_equal @data[i], line
@@ -275,7 +274,7 @@ class ReaderTest < Minitest::Test
         end
       end
 
-      it "support rewind" do
+      it 'support rewind' do
         decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
           file.read
           file.rewind
@@ -285,7 +284,7 @@ class ReaderTest < Minitest::Test
       end
     end
 
-    describe "reading from files with previous keys without a header" do
+    describe 'reading from files with previous keys without a header' do
       before do
         @filename = '_test'
         # Create encrypted file with old encryption key
@@ -302,12 +301,12 @@ class ReaderTest < Minitest::Test
         end
       end
 
-      it "decrypt from file in a single read" do
+      it 'decrypt from file in a single read' do
         decrypted = SymmetricEncryption::Reader.open(@filename, version: 0) { |file| file.read }
         assert_equal @data_str, decrypted
       end
 
-      it "decrypt from file in a single read with different version" do
+      it 'decrypt from file in a single read with different version' do
         # Should fail since file was encrypted using version 0 key
         assert_raises OpenSSL::Cipher::CipherError do
           SymmetricEncryption::Reader.open(@filename, version: 2) { |file| file.read }

data/test/symmetric_encryption_test.rb

@@ -54,7 +54,7 @@ class SymmetricEncryptionTest < Minitest::Test
             when :base16
               '40456e4302004bef17d4d46ba9d7c4210c851d53ee54'
             when :none
-              "@EnC\x02\x00K\xEF\x17\xD4\xD4k\xA9\xD7\xC4!\f\x85\x1DS\xEET".force_encoding(Encoding.find("binary"))
+              "@EnC\x02\x00K\xEF\x17\xD4\xD4k\xA9\xD7\xC4!\f\x85\x1DS\xEET".force_encoding(Encoding.find('binary'))
             else
               raise "Add test for encoding: #{encoding}"
             end
@@ -68,11 +68,11 @@ class SymmetricEncryptionTest < Minitest::Test
           SymmetricEncryption.cipher.encoding = @encoding
         end
 
-        it "encrypt simple string" do
+        it 'encrypt simple string' do
           assert_equal @social_security_number_encrypted, SymmetricEncryption.encrypt(@social_security_number)
         end
 
-        it "decrypt string" do
+        it 'decrypt string' do
           assert decrypted = SymmetricEncryption.decrypt(@social_security_number_encrypted)
           assert_equal @social_security_number, decrypted
           assert_equal Encoding.find('utf-8'), decrypted.encoding, decrypted
@@ -88,7 +88,7 @@ class SymmetricEncryptionTest < Minitest::Test
           assert_equal @non_utf8, decrypted
         end
 
-        it "return nil when encrypting nil" do
+        it 'return nil when encrypting nil' do
           assert_equal nil, SymmetricEncryption.encrypt(nil)
         end
 
@@ -96,7 +96,7 @@ class SymmetricEncryptionTest < Minitest::Test
           assert_equal '', SymmetricEncryption.encrypt('')
         end
 
-        it "return nil when decrypting nil" do
+        it 'return nil when decrypting nil' do
           assert_equal nil, SymmetricEncryption.decrypt(nil)
         end
 
@@ -104,16 +104,16 @@ class SymmetricEncryptionTest < Minitest::Test
           assert_equal '', SymmetricEncryption.decrypt('')
         end
 
-        it "determine if string is encrypted" do
+        it 'determine if string is encrypted' do
           assert_equal true, SymmetricEncryption.encrypted?(@social_security_number_encrypted)
           assert_equal false, SymmetricEncryption.encrypted?(@social_security_number)
         end
       end
     end
 
-    describe "using select_cipher" do
+    describe 'using select_cipher' do
       before do
-        @social_security_number = "987654321"
+        @social_security_number = '987654321'
         # Encrypt data without a header and encode with base64 which has a trailing '\n'
         @encrypted_0_ssn        = SymmetricEncryption.cipher(0).encode(SymmetricEncryption.cipher(0).binary_encrypt(@social_security_number, false, false, false))
 
@@ -129,164 +129,164 @@ class SymmetricEncryptionTest < Minitest::Test
         SymmetricEncryption.select_cipher
       end
 
-      it "decrypt string without a header using an old cipher" do
+      it 'decrypt string without a header using an old cipher' do
         assert_equal @social_security_number, SymmetricEncryption.decrypt(@encrypted_0_ssn)
       end
     end
 
-    describe "without select_cipher" do
+    describe 'without select_cipher' do
       before do
-        @social_security_number = "987654321"
+        @social_security_number = '987654321'
         # Encrypt data without a header and encode with base64 which has a trailing '\n'
         assert @encrypted_0_ssn = SymmetricEncryption.cipher(0).encode(SymmetricEncryption.cipher(0).binary_encrypt(@social_security_number, false, false, false))
       end
 
-      it "decrypt string without a header using an old cipher" do
+      it 'decrypt string without a header using an old cipher' do
         assert_raises OpenSSL::Cipher::CipherError do
           SymmetricEncryption.decrypt(@encrypted_0_ssn)
         end
       end
     end
 
-    describe "random iv" do
+    describe 'random iv' do
       before do
-        @social_security_number = "987654321"
+        @social_security_number = '987654321'
       end
 
-      it "encrypt and then decrypt using random iv" do
+      it 'encrypt and then decrypt using random iv' do
         # Encrypt with random iv
-        assert encrypted = SymmetricEncryption.encrypt(@social_security_number, random_iv=true)
+        assert encrypted = SymmetricEncryption.encrypt(@social_security_number, true)
         assert_equal true, SymmetricEncryption.encrypted?(encrypted)
         assert_equal @social_security_number, SymmetricEncryption.decrypt(encrypted)
       end
 
-      it "encrypt and then decrypt using random iv with compression" do
+      it 'encrypt and then decrypt using random iv with compression' do
         # Encrypt with random iv and compress
-        assert encrypted = SymmetricEncryption.encrypt(@social_security_number, random_iv=true, compress=true)
+        assert encrypted = SymmetricEncryption.encrypt(@social_security_number, true, true)
         assert_equal true, SymmetricEncryption.encrypted?(encrypted)
         assert_equal @social_security_number, SymmetricEncryption.decrypt(encrypted)
       end
     end
 
-    describe "data types" do
-      describe "string" do
+    describe 'data types' do
+      describe 'string' do
         before do
-          @social_security_number = "987654321"
+          @social_security_number = '987654321'
         end
 
-        it "encrypt and decrypt value to and from a string" do
-          assert encrypted = SymmetricEncryption.encrypt(@social_security_number, random_iv=false, compress=false, type=:string)
+        it 'encrypt and decrypt value to and from a string' do
+          assert encrypted = SymmetricEncryption.encrypt(@social_security_number, false, false, :string)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-          assert_equal @social_security_number, SymmetricEncryption.decrypt(encrypted, version=nil, type=:string)
+          assert_equal @social_security_number, SymmetricEncryption.decrypt(encrypted, nil, :string)
         end
       end
 
-      describe "integer" do
+      describe 'integer' do
         before do
           @age = 21
         end
 
-        it "encrypt and decrypt value to and from an integer" do
-          assert encrypted = SymmetricEncryption.encrypt(@age, random_iv=false, compress=false, type=:integer)
+        it 'encrypt and decrypt value to and from an integer' do
+          assert encrypted = SymmetricEncryption.encrypt(@age, false, false, :integer)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-          assert_equal @age, SymmetricEncryption.decrypt(encrypted, version=nil, type=:integer)
+          assert_equal @age, SymmetricEncryption.decrypt(encrypted, nil, :integer)
         end
       end
 
-      describe "float" do
+      describe 'float' do
         before do
           @miles = 2.5
         end
 
-        it "encrypt and decrypt value to and from a float" do
-          assert encrypted = SymmetricEncryption.encrypt(@miles, random_iv=false, compress=false, type=:float)
+        it 'encrypt and decrypt value to and from a float' do
+          assert encrypted = SymmetricEncryption.encrypt(@miles, false, false, :float)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-          assert_equal @miles, SymmetricEncryption.decrypt(encrypted, version=nil, type=:float)
+          assert_equal @miles, SymmetricEncryption.decrypt(encrypted, nil, :float)
         end
       end
 
-      describe "decimal" do
+      describe 'decimal' do
         before do
-          @account_balance = BigDecimal.new("12.58")
+          @account_balance = BigDecimal.new('12.58')
         end
 
-        it "encrypt and decrypt value to and from a BigDecimal" do
-          assert encrypted = SymmetricEncryption.encrypt(@account_balance, random_iv=false, compress=false, type=:decimal)
+        it 'encrypt and decrypt value to and from a BigDecimal' do
+          assert encrypted = SymmetricEncryption.encrypt(@account_balance, false, false, :decimal)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-          assert_equal @account_balance, SymmetricEncryption.decrypt(encrypted, version=nil, type=:decimal)
+          assert_equal @account_balance, SymmetricEncryption.decrypt(encrypted, nil, :decimal)
         end
       end
 
-      describe "datetime" do
+      describe 'datetime' do
         before do
           @checked_in_at = DateTime.new(2001, 11, 26, 20, 55, 54, "-5")
         end
 
-        it "encrypt and decrypt value to and from a DateTime" do
-          assert encrypted = SymmetricEncryption.encrypt(@checked_in_at, random_iv=false, compress=false, type=:datetime)
+        it 'encrypt and decrypt value to and from a DateTime' do
+          assert encrypted = SymmetricEncryption.encrypt(@checked_in_at, false, false, :datetime)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-          assert_equal @checked_in_at, SymmetricEncryption.decrypt(encrypted, version=nil, type=:datetime)
+          assert_equal @checked_in_at, SymmetricEncryption.decrypt(encrypted, nil, :datetime)
         end
       end
 
-      describe "time" do
+      describe 'time' do
         before do
           @closing_time = Time.new(2013, 01, 01, 22, 30, 00, "-04:00")
         end
 
-        it "encrypt and decrypt value to and from a Time" do
-          assert encrypted = SymmetricEncryption.encrypt(@closing_time, random_iv=false, compress=false, type=:time)
+        it 'encrypt and decrypt value to and from a Time' do
+          assert encrypted = SymmetricEncryption.encrypt(@closing_time, false, false, :time)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-          assert_equal @closing_time, SymmetricEncryption.decrypt(encrypted, version=nil, type=:time)
+          assert_equal @closing_time, SymmetricEncryption.decrypt(encrypted, nil, :time)
         end
       end
 
-      describe "date" do
+      describe 'date' do
         before do
           @birthdate = Date.new(1927, 04, 01)
         end
 
-        it "encrypt and decrypt value to and from a Date" do
-          assert encrypted = SymmetricEncryption.encrypt(@birthdate, random_iv=false, compress=false, type=:date)
+        it 'encrypt and decrypt value to and from a Date' do
+          assert encrypted = SymmetricEncryption.encrypt(@birthdate, false, false, :date)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-          assert_equal @birthdate, SymmetricEncryption.decrypt(encrypted, version=nil, type=:date)
+          assert_equal @birthdate, SymmetricEncryption.decrypt(encrypted, nil, :date)
         end
       end
 
-      describe "boolean" do
-        describe "when true" do
+      describe 'boolean' do
+        describe 'when true' do
           before do
             @is_working = true
           end
 
-          it "encrypt and decrypt a true value to and from a boolean" do
-            assert encrypted = SymmetricEncryption.encrypt(@is_working, random_iv=false, compress=false, type=:boolean)
+          it 'encrypt and decrypt a true value to and from a boolean' do
+            assert encrypted = SymmetricEncryption.encrypt(@is_working, false, false, :boolean)
             assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-            assert_equal @is_working, SymmetricEncryption.decrypt(encrypted, version=nil, type=:boolean)
+            assert_equal @is_working, SymmetricEncryption.decrypt(encrypted, nil, :boolean)
           end
         end
 
-        describe "when false" do
+        describe 'when false' do
           before do
             @is_broken = false
           end
 
-          it "encrypt and decrypt a false value to and from a boolean" do
-            assert encrypted = SymmetricEncryption.encrypt(@is_broken, random_iv=false, compress=false, type=:boolean)
+          it 'encrypt and decrypt a false value to and from a boolean' do
+            assert encrypted = SymmetricEncryption.encrypt(@is_broken, false, false, :boolean)
             assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-            assert_equal @is_broken, SymmetricEncryption.decrypt(encrypted, version=nil, type=:boolean)
+            assert_equal @is_broken, SymmetricEncryption.decrypt(encrypted, nil, :boolean)
           end
         end
 
-        describe "when yaml" do
+        describe 'when yaml' do
           before do
             @test = {:a => :b}
           end
 
-          it "encrypt and decrypt a false value to and from a boolean" do
-            assert encrypted = SymmetricEncryption.encrypt(@test, random_iv=false, compress=false, type=:yaml)
+          it 'encrypt and decrypt a false value to and from a boolean' do
+            assert encrypted = SymmetricEncryption.encrypt(@test, false, false, :yaml)
             assert_equal true, SymmetricEncryption.encrypted?(encrypted)
-            assert_equal @test, SymmetricEncryption.decrypt(encrypted, version=nil, type=:yaml)
+            assert_equal @test, SymmetricEncryption.decrypt(encrypted, nil, :yaml)
           end
         end
 

data/test/test_helper.rb

@@ -10,9 +10,15 @@ require 'active_record'
 require 'symmetric-encryption'
 require 'awesome_print'
 
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+begin
+  require 'active_model/serializers'
+rescue LoadError
+  # Only used when running Rails 5 and MongoMapper
+end
 
-SemanticLogger.add_appender('test.log', &SemanticLogger::Appender::Base.colorized_formatter)
+#Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+SemanticLogger.add_appender(file_name: 'test.log', formatter: :color)
 SemanticLogger.default_level = :trace
 
 # Load Symmetric Encryption keys

data/test/writer_test.rb

@@ -9,7 +9,7 @@ class WriterTest < Minitest::Test
       @data                    = [
         "Hello World\n",
         "Keep this secret\n",
-        "And keep going even further and further..."
+        'And keep going even further and further...'
       ]
       @data_str                = @data.inject('') { |sum, str| sum << str }
       @data_len                = @data_str.length
@@ -25,7 +25,7 @@ class WriterTest < Minitest::Test
       File.delete(@filename) if File.exist?(@filename)
     end
 
-    it "encrypt to string stream" do
+    it 'encrypt to string stream' do
       stream      = StringIO.new
       file        = SymmetricEncryption::Writer.new(stream, header: false, random_key: false, random_iv: false)
       written_len = @data.inject(0) { |sum, str| sum + file.write(str) }
@@ -38,7 +38,7 @@ class WriterTest < Minitest::Test
       assert_equal @data_encrypted, result
     end
 
-    it "encrypt to string stream using .open" do
+    it 'encrypt to string stream using .open' do
       written_len = 0
       stream      = StringIO.new
       SymmetricEncryption::Writer.open(stream) do |file|
@@ -48,7 +48,7 @@ class WriterTest < Minitest::Test
       assert_equal @data_len, written_len
     end
 
-    it "encrypt to file using .open" do
+    it 'encrypt to file using .open' do
       written_len = nil
       SymmetricEncryption::Writer.open(@filename, header: false, random_key: false, random_iv: false) do |file|
         written_len = @data.inject(0) { |sum, str| sum + file.write(str) }