symmetric-encryption 4.0.0 → 4.0.1

data/lib/symmetric_encryption/symmetric_encryption.rb

@@ -8,7 +8,6 @@ require 'erb'
 # The symmetric key is protected using the private key below and must
 # be distributed separately from the application
 module SymmetricEncryption
-
   # Defaults
   @@cipher            = nil
   @@secondary_ciphers = []
@@ -26,7 +25,7 @@ module SymmetricEncryption
   #   :date      => Date
   #   :json      => Uses JSON serialization, useful for hashes and arrays
   #   :yaml      => Uses YAML serialization, useful for hashes and arrays
-  COERCION_TYPES = [:string, :integer, :float, :decimal, :datetime, :time, :date, :boolean, :json, :yaml]
+  COERCION_TYPES = %i[string integer float decimal datetime time date boolean json yaml].freeze
 
   # Set the Primary Symmetric Cipher to be used
   #
@@ -48,10 +47,15 @@ module SymmetricEncryption
   #   Returns the primary cipher if no match was found and version == 0
   #   Returns nil if no match was found and version != 0
   def self.cipher(version = nil)
-    raise(SymmetricEncryption::ConfigError, 'Call SymmetricEncryption.load! or SymmetricEncryption.cipher= prior to encrypting or decrypting data') unless cipher?
+    unless cipher?
+      raise(
+        SymmetricEncryption::ConfigError,
+        'Call SymmetricEncryption.load! or SymmetricEncryption.cipher= prior to encrypting or decrypting data'
+      )
+    end
 
     return @@cipher if version.nil? || (@@cipher.version == version)
-    secondary_ciphers.find { |c| c.version == version } || (@@cipher if version == 0)
+    secondary_ciphers.find { |c| c.version == version } || (@@cipher if version.zero?)
   end
 
   # Returns whether a primary cipher has been set
@@ -139,9 +143,7 @@ module SymmetricEncryption
       end
 
     # Try to force result to UTF-8 encoding, but if it is not valid, force it back to Binary
-    unless decrypted.force_encoding(SymmetricEncryption::UTF8_ENCODING).valid_encoding?
-      decrypted.force_encoding(SymmetricEncryption::BINARY_ENCODING)
-    end
+    decrypted.force_encoding(SymmetricEncryption::BINARY_ENCODING) unless decrypted.force_encoding(SymmetricEncryption::UTF8_ENCODING).valid_encoding?
     Coerce.coerce_from_string(decrypted, type)
   end
 
@@ -155,7 +157,7 @@ module SymmetricEncryption
     return if decoded.nil? || decoded.empty?
 
     h = Header.new
-    h.parse(decoded) == 0 ? nil : h
+    h.parse(decoded).zero? ? nil : h
   end
 
   # AES Symmetric Encryption of supplied string

data/lib/symmetric_encryption/utils/re_encrypt_files.rb

@@ -39,7 +39,7 @@ module SymmetricEncryption
 
       # Re-encrypt the supplied encrypted value with the new cipher
       def re_encrypt(encrypted)
-        if unencrypted = SymmetricEncryption.try_decrypt(encrypted)
+        if (unencrypted = SymmetricEncryption.try_decrypt(encrypted))
           cipher.encrypt(unencrypted)
         else
           encrypted
@@ -72,9 +72,7 @@ module SymmetricEncryption
               line
             end
         end
-        if hits > 0
-          File.open(file_name, 'wb') { |file| file.write(output_lines) }
-        end
+        File.open(file_name, 'wb') { |file| file.write(output_lines) } if hits.positive?
         hits
       end
 
@@ -86,7 +84,7 @@ module SymmetricEncryption
         end
         File.delete(file_name)
         File.rename(temp_file_name, file_name)
-      rescue
+      rescue StandardError
         File.delete(temp_file_name) if temp_file_name && File.exist?(temp_file_name)
         raise
       end
@@ -101,7 +99,7 @@ module SymmetricEncryption
         Dir[path].each do |file_name|
           next if File.directory?(file_name)
 
-          if v = encrypted_file_version(file_name)
+          if (v = encrypted_file_version(file_name))
             if v == version
               puts "Skipping already re-encrypted file: #{file_name}"
             else
@@ -111,7 +109,7 @@ module SymmetricEncryption
           else
             begin
               count = re_encrypt_contents(file_name)
-              puts "Re-encrypted #{count} encrypted value(s) in: #{file_name}" if count > 0
+              puts "Re-encrypted #{count} encrypted value(s) in: #{file_name}" if count.positive?
             rescue StandardError => exc
               puts "Failed re-encrypting the file contents of: #{file_name}. #{exc.class.name}: #{exc.message}"
             end
@@ -135,7 +133,6 @@ module SymmetricEncryption
       rescue OpenSSL::Cipher::CipherError
         nil
       end
-
     end
   end
 end

data/lib/symmetric_encryption/version.rb

@@ -1,3 +1,3 @@
-module SymmetricEncryption #:nodoc
-  VERSION = '4.0.0'
+module SymmetricEncryption
+  VERSION = '4.0.1'.freeze
 end

data/lib/symmetric_encryption/writer.rb

@@ -51,7 +51,7 @@ module SymmetricEncryption
       ios = file_name_or_stream.is_a?(String) ? ::File.open(file_name_or_stream, 'wb') : file_name_or_stream
 
       begin
-        file = self.new(ios, compress: compress, **args)
+        file = new(ios, compress: compress, **args)
         file = Zlib::GzipWriter.new(file) if compress
         block_given? ? yield(file) : file
       ensure
@@ -64,7 +64,7 @@ module SymmetricEncryption
     # Notes:
     # * Do not use this method for writing large files.
     def self.write(file_name_or_stream, data, **args)
-      open(file_name_or_stream, **args) { |f| f.write(data) }
+      self.open(file_name_or_stream, **args) { |f| f.write(data) }
     end
 
     # Encrypt an entire file.
@@ -89,17 +89,15 @@ module SymmetricEncryption
     #
     # Notes:
     # * The file contents are streamed so that the entire file is _not_ loaded into memory.
-    def self.encrypt(source:, target:, block_size: 65535, **args)
+    def self.encrypt(source:, target:, block_size: 65_535, **args)
       source_ios    = source.is_a?(String) ? ::File.open(source, 'rb') : source
       bytes_written = 0
-      open(target, **args) do |output_file|
-        while !source_ios.eof?
-          bytes_written += output_file.write(source_ios.read(block_size))
-        end
+      self.open(target, **args) do |output_file|
+        bytes_written += output_file.write(source_ios.read(block_size)) until source_ios.eof?
       end
       bytes_written
     ensure
-      source_ios.close if source_ios && source_ios.respond_to?(:closed?) && !source_ios.closed?
+      source_ios.close if source_ios&.respond_to?(:closed?) && !source_ios.closed?
     end
 
     # Encrypt data before writing to the supplied stream
@@ -114,9 +112,7 @@ module SymmetricEncryption
       raise(SymmetricEncryption::CipherError, "Cipher with version:#{version} not found in any of the configured SymmetricEncryption ciphers") unless cipher
 
       # Force header if compressed or using random iv, key
-      if (header == true) || compress || random_key || random_iv
-        header = Header.new(version: cipher.version, compress: compress, cipher_name: cipher_name)
-      end
+      header = Header.new(version: cipher.version, compress: compress, cipher_name: cipher_name) if (header == true) || compress || random_key || random_iv
 
       @stream_cipher = ::OpenSSL::Cipher.new(cipher_name || cipher.cipher_name)
       @stream_cipher.encrypt
@@ -129,8 +125,8 @@ module SymmetricEncryption
 
       if random_iv
         header.iv = @stream_cipher.iv = @stream_cipher.random_iv
-      else
-        @stream_cipher.iv = cipher.iv if cipher.iv
+      elsif cipher.iv
+        @stream_cipher.iv = cipher.iv
       end
 
       @ios.write(header.to_s) if header
@@ -153,9 +149,9 @@ module SymmetricEncryption
     # ensure that the encrypted stream is closed before the stream itself is closed.
     def close(close_child_stream = true)
       return if closed?
-      if size > 0
+      if size.positive?
         final = @stream_cipher.final
-        @ios.write(final) if final.length > 0
+        @ios.write(final) unless final.empty?
       end
       @ios.close if close_child_stream
       @closed = true
@@ -170,7 +166,7 @@ module SymmetricEncryption
       bytes   = data.to_s
       @size   += bytes.size
       partial = @stream_cipher.update(bytes)
-      @ios.write(partial) if partial.length > 0
+      @ios.write(partial) unless partial.empty?
       data.length
     end
 
@@ -201,6 +197,5 @@ module SymmetricEncryption
     # Returns [Integer] the number of unencrypted and uncompressed bytes
     # written to the file so far.
     attr_reader :size
-
   end
 end

data/test/active_record_test.rb

@@ -1,9 +1,9 @@
 require_relative 'test_helper'
 
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read('test/config/database.yml')).result)
+ActiveRecord::Base.configurations = YAML.safe_load(ERB.new(IO.read('test/config/database.yml')).result)
 ActiveRecord::Base.establish_connection(:test)
 
-#@formatter:off
+# @formatter:off
 ActiveRecord::Schema.define version: 0 do
   create_table :users, force: true do |t|
     t.string :encrypted_bank_account_number
@@ -59,7 +59,7 @@ class User < ActiveRecord::Base
   attr_encrypted :text,           type: :string
   attr_encrypted :number,         type: :integer
 
-  validates      :text, format: { with: /\A[a-zA-Z ]+\z/, message: 'only allows letters' }, presence: true
+  validates      :text, format: {with: /\A[a-zA-Z ]+\z/, message: 'only allows letters'}, presence: true
   validates      :number, presence: true
 end
 
@@ -71,11 +71,11 @@ class UniqueUser < ActiveRecord::Base
   validates_uniqueness_of :encrypted_username, allow_blank: true, if: :encrypted_username_changed?
 
   validates :username,
-    length:      {in: 3..20},
-    format:      {with: /\A[\w\-]+\z/},
-    allow_blank: true
+            length:      {in: 3..20},
+            format:      {with: /\A[\w\-]+\z/},
+            allow_blank: true
 end
-#@formatter:on
+# @formatter:on
 
 #
 # Unit Test for attr_encrypted extensions in ActiveRecord
@@ -84,31 +84,45 @@ class ActiveRecordTest < Minitest::Test
   describe 'ActiveRecord' do
     INTEGER_VALUE       = 12
     FLOAT_VALUE         = 88.12345
-    DECIMAL_VALUE       = BigDecimal.new('22.51')
-    DATETIME_VALUE      = DateTime.new(2001, 11, 26, 20, 55, 54, "-5")
-    TIME_VALUE          = Time.new(2013, 01, 01, 22, 30, 00, "-04:00")
-    DATE_VALUE          = Date.new(1927, 04, 02)
-    STRING_VALUE        = 'A string containing some data to be encrypted with a random initialization vector'
-    LONG_STRING_VALUE   = 'A string containing some data to be encrypted with a random initialization vector and compressed since it takes up so much space in plain text form'
+    DECIMAL_VALUE       = BigDecimal('22.51')
+    DATETIME_VALUE      = DateTime.new(2001, 11, 26, 20, 55, 54, '-5')
+    TIME_VALUE          = Time.new(2013, 1, 1, 22, 30, 0, '-04:00')
+    DATE_VALUE          = Date.new(1927, 4, 2)
+    STRING_VALUE        = 'A string containing some data to be encrypted with a random initialization vector'.freeze
+    LONG_STRING_VALUE   = 'A string containing some data to be encrypted with a random initialization vector and compressed since it takes up so much space in plain text form'.freeze
     BINARY_STRING_VALUE = "Non-UTF8 Binary \x92 string".force_encoding('BINARY')
 
-    before do
-      @bank_account_number           = '1234567890'
-      @bank_account_number_encrypted = 'QEVuQwIAL94ArJeFlJrZp6SYsvoOGA=='
+    let :bank_account_number do
+      '1234567890'
+    end
 
-      @social_security_number           = '987654321'
-      @social_security_number_encrypted = 'QEVuQwIAS+8X1NRrqdfEIQyFHVPuVA=='
+    let :bank_account_number_encrypted do
+      'QEVuQwIAL94ArJeFlJrZp6SYsvoOGA=='
+    end
 
-      @name = 'Joe Bloggs'
+    let :social_security_number do
+      '987654321'
+    end
 
-      @h = {a: 'A', b: 'B'}
+    let :social_security_number_encrypted do
+      'QEVuQwIAS+8X1NRrqdfEIQyFHVPuVA=='
+    end
 
-      @user = User.new(
+    let :person_name do
+      'Joe Bloggs'
+    end
+
+    let :hash_data do
+      {a: 'A', b: 'B'}
+    end
+
+    let :user do
+      User.new(
         # Encrypted Attribute
-        bank_account_number: @bank_account_number,
+        bank_account_number: bank_account_number,
         # Encrypted Attribute
-        social_security_number: @social_security_number,
-        name:                   @name,
+        social_security_number: social_security_number,
+        name:                   person_name,
         # data type specific fields
         string_value:        STRING_VALUE,
         long_string_value:   LONG_STRING_VALUE,
@@ -121,127 +135,127 @@ class ActiveRecordTest < Minitest::Test
         date_value:          DATE_VALUE,
         true_value:          true,
         false_value:         false,
-        data_yaml:           @h.dup,
-        data_json:           @h.dup,
+        data_yaml:           hash_data.dup,
+        data_json:           hash_data.dup,
         text:                'hello',
         number:              '21'
       )
     end
 
     it 'has encrypted methods' do
-      assert_equal true, @user.respond_to?(:encrypted_bank_account_number)
-      assert_equal true, @user.respond_to?(:bank_account_number)
-      assert_equal true, @user.respond_to?(:encrypted_social_security_number)
-      assert_equal true, @user.respond_to?(:social_security_number)
-      assert_equal true, @user.respond_to?(:data_yaml)
-      assert_equal true, @user.respond_to?(:data_json)
-      assert_equal false, @user.respond_to?(:encrypted_name)
-      assert_equal true, @user.respond_to?(:encrypted_bank_account_number_changed?)
-      assert_equal true, @user.respond_to?(:bank_account_number_changed?)
+      assert_equal true, user.respond_to?(:encrypted_bank_account_number)
+      assert_equal true, user.respond_to?(:bank_account_number)
+      assert_equal true, user.respond_to?(:encrypted_social_security_number)
+      assert_equal true, user.respond_to?(:social_security_number)
+      assert_equal true, user.respond_to?(:data_yaml)
+      assert_equal true, user.respond_to?(:data_json)
+      assert_equal false, user.respond_to?(:encrypted_name)
+      assert_equal true, user.respond_to?(:encrypted_bank_account_number_changed?)
+      assert_equal true, user.respond_to?(:bank_account_number_changed?)
     end
 
     it 'has unencrypted values' do
-      assert_equal @bank_account_number, @user.bank_account_number
-      assert_equal @social_security_number, @user.social_security_number
+      assert_equal bank_account_number, user.bank_account_number
+      assert_equal social_security_number, user.social_security_number
     end
 
     it 'has encrypted values' do
-      assert_equal @bank_account_number_encrypted, @user.encrypted_bank_account_number
-      assert_equal @social_security_number_encrypted, @user.encrypted_social_security_number
+      assert_equal bank_account_number_encrypted, user.encrypted_bank_account_number
+      assert_equal social_security_number_encrypted, user.encrypted_social_security_number
     end
 
     describe ':random_iv' do
       it 'false' do
-        @user.social_security_number = @social_security_number
-        assert first_value = @user.social_security_number
+        user.social_security_number = social_security_number
+        assert first_value = user.social_security_number
         # Assign the same value
-        @user.social_security_number = @social_security_number
-        assert_equal first_value, @user.social_security_number
+        user.social_security_number = social_security_number
+        assert_equal first_value, user.social_security_number
       end
 
       it 'true' do
-        @user.string_value = STRING_VALUE
-        assert first_value = @user.encrypted_string_value
-        @user.string_value = 'blah'
-        @user.string_value = STRING_VALUE
-        refute_equal first_value, @user.encrypted_string_value
+        user.string_value = STRING_VALUE
+        assert first_value = user.encrypted_string_value
+        user.string_value = 'blah'
+        user.string_value = STRING_VALUE
+        refute_equal first_value, user.encrypted_string_value
       end
 
       it 'true and compress: true' do
-        @user.string_value      = STRING_VALUE
-        @user.long_string_value = STRING_VALUE
+        user.string_value      = STRING_VALUE
+        user.long_string_value = STRING_VALUE
 
-        refute_equal @user.encrypted_long_string_value, @user.encrypted_string_value
+        refute_equal user.encrypted_long_string_value, user.encrypted_string_value
       end
 
       describe 'changed?' do
         it 'true for a new instance' do
-          assert @user.string_value_changed?
+          assert user.string_value_changed?
         end
 
         it 'clears after save' do
-          @user.save!
-          refute @user.string_value_changed?
+          user.save!
+          refute user.string_value_changed?
         end
 
         it 'does not change when equal' do
-          @user.save!
-          before             = @user.encrypted_string_value
-          @user.string_value = STRING_VALUE
-          refute @user.string_value_changed?
-          assert_equal before, @user.encrypted_string_value
+          user.save!
+          before             = user.encrypted_string_value
+          user.string_value = STRING_VALUE
+          refute user.string_value_changed?
+          assert_equal before, user.encrypted_string_value
         end
       end
     end
 
     describe 'attribute=' do
       it 'handles nil' do
-        @user.string_value = nil
-        assert_nil @user.string_value
-        assert_nil @user.encrypted_string_value
-        @user.save!
-        @user.reload
-        assert_nil @user.string_value
-        assert_nil @user.encrypted_string_value
+        user.string_value = nil
+        assert_nil user.string_value
+        assert_nil user.encrypted_string_value
+        user.save!
+        user.reload
+        assert_nil user.string_value
+        assert_nil user.encrypted_string_value
       end
 
       it 'handles empty string' do
-        @user.string_value = ''
-        assert_equal '', @user.string_value
-        assert_equal '', @user.encrypted_string_value
-        @user.save!
-        @user.reload
-        assert_equal '', @user.string_value
-        assert_equal '', @user.encrypted_string_value
+        user.string_value = ''
+        assert_equal '', user.string_value
+        assert_equal '', user.encrypted_string_value
+        user.save!
+        user.reload
+        assert_equal '', user.string_value
+        assert_equal '', user.encrypted_string_value
       end
 
       it 'encrypt' do
         user                     = User.new
-        user.bank_account_number = @bank_account_number
-        assert_equal @bank_account_number, user.bank_account_number
-        assert_equal @bank_account_number_encrypted, user.encrypted_bank_account_number
+        user.bank_account_number = bank_account_number
+        assert_equal bank_account_number, user.bank_account_number
+        assert_equal bank_account_number_encrypted, user.encrypted_bank_account_number
       end
 
       it 'all paths it lead to the same result' do
-        assert_equal @bank_account_number_encrypted, (@user.encrypted_social_security_number = @bank_account_number_encrypted)
-        assert_equal @bank_account_number, @user.social_security_number
-        assert_equal @bank_account_number_encrypted, @user.encrypted_social_security_number
+        assert_equal bank_account_number_encrypted, (user.encrypted_social_security_number = bank_account_number_encrypted)
+        assert_equal bank_account_number, user.social_security_number
+        assert_equal bank_account_number_encrypted, user.encrypted_social_security_number
       end
 
       it 'all paths it lead to the same result 2' do
-        assert_equal @bank_account_number, (@user.social_security_number = @bank_account_number)
-        assert_equal @bank_account_number_encrypted, @user.encrypted_social_security_number
-        assert_equal @bank_account_number, @user.social_security_number
+        assert_equal bank_account_number, (user.social_security_number = bank_account_number)
+        assert_equal bank_account_number_encrypted, user.encrypted_social_security_number
+        assert_equal bank_account_number, user.social_security_number
       end
 
       it 'all paths it lead to the same result, check uninitialized' do
         user = User.new
         assert_nil user.social_security_number
-        assert_equal @bank_account_number, (user.social_security_number = @bank_account_number)
-        assert_equal @bank_account_number, user.social_security_number
-        assert_equal @bank_account_number_encrypted, user.encrypted_social_security_number
+        assert_equal bank_account_number, (user.social_security_number = bank_account_number)
+        assert_equal bank_account_number, user.social_security_number
+        assert_equal bank_account_number_encrypted, user.encrypted_social_security_number
 
-        assert_nil (user.social_security_number = nil)
+        user.social_security_number = nil
         assert_nil user.social_security_number
         assert_nil user.encrypted_social_security_number
       end
@@ -249,11 +263,11 @@ class ActiveRecordTest < Minitest::Test
 
     describe '.new' do
       it 'allows unencrypted values to be passed to the constructor' do
-        user = User.new(bank_account_number: @bank_account_number, social_security_number: @social_security_number)
-        assert_equal @bank_account_number, user.bank_account_number
-        assert_equal @social_security_number, user.social_security_number
-        assert_equal @bank_account_number_encrypted, user.encrypted_bank_account_number
-        assert_equal @social_security_number_encrypted, user.encrypted_social_security_number
+        user = User.new(bank_account_number: bank_account_number, social_security_number: social_security_number)
+        assert_equal bank_account_number, user.bank_account_number
+        assert_equal social_security_number, user.social_security_number
+        assert_equal bank_account_number_encrypted, user.encrypted_bank_account_number
+        assert_equal social_security_number_encrypted, user.encrypted_social_security_number
       end
     end
 
@@ -261,13 +275,13 @@ class ActiveRecordTest < Minitest::Test
       it 'returns encrypted attributes for the class' do
         expect = {social_security_number: :encrypted_social_security_number, bank_account_number: :encrypted_bank_account_number}
         result = User.encrypted_attributes
-        expect.each_pair { |k, v| assert_equal expect[k], result[k] }
+        expect.each_pair { |k, _v| assert_equal expect[k], result[k] }
       end
     end
 
     describe '.encrypted_keys' do
       it 'return encrypted keys for the class' do
-        expect = [:social_security_number, :bank_account_number]
+        expect = %i[social_security_number bank_account_number]
         result = User.encrypted_keys
         expect.each { |val| assert result.include?(val) }
 
@@ -278,7 +292,7 @@ class ActiveRecordTest < Minitest::Test
 
     describe '.encrypted_columns' do
       it 'return encrypted columns for the class' do
-        expect = [:encrypted_social_security_number, :encrypted_bank_account_number]
+        expect = %i[encrypted_social_security_number encrypted_bank_account_number]
         result = User.encrypted_columns
         expect.each { |val| assert result.include?(val) }
 
@@ -288,123 +302,152 @@ class ActiveRecordTest < Minitest::Test
     end
 
     describe '#valid?' do
-      it 'validate encrypted data' do
-        assert @user.valid?
-        @user.encrypted_bank_account_number = '123'
-        assert_equal false, @user.valid?
-        assert_equal ['must be a value encrypted using SymmetricEncryption.encrypt'], @user.errors[:encrypted_bank_account_number]
-        @user.encrypted_bank_account_number = SymmetricEncryption.encrypt('123')
-        assert @user.valid?
-        @user.bank_account_number = '123'
-        assert @user.valid?
+      before do
+        assert user.valid?
+      end
+
+      it 'fails invalid data' do
+        user.encrypted_bank_account_number = '123'
+        assert_equal false, user.valid?
+        assert_equal ['must be a value encrypted using SymmetricEncryption.encrypt'], user.errors[:encrypted_bank_account_number]
+      end
+
+      it 'passes encrypted data' do
+        user.encrypted_bank_account_number = SymmetricEncryption.encrypt('123')
+        assert user.valid?
+      end
+
+      it 'passes valid data' do
+        user.bank_account_number = '123'
+        assert user.valid?
+      end
+
+      it 'passes nil encrypted data' do
+        user.encrypted_bank_account_number = nil
+        assert user.valid?
+      end
+
+      it 'passes empty string encrypted data' do
+        user.encrypted_bank_account_number = ''
+        assert user.valid?
+      end
+
+      it 'passes nil data' do
+        user.bank_account_number = nil
+        assert user.valid?
+      end
+
+      it 'passes empty string data' do
+        user.bank_account_number = ''
+        assert user.valid?
       end
 
       it 'validate un-encrypted string data' do
-        assert @user.valid?
-        @user.text = '123'
-        assert_equal false, @user.valid?
-        assert_equal ['only allows letters'], @user.errors[:text]
-        @user.text = nil
-        assert_equal false, @user.valid?
-        assert_equal ['only allows letters', "can't be blank"], @user.errors[:text]
-        @user.text = ''
-        assert_equal false, @user.valid?
-        assert_equal ['only allows letters', "can't be blank"], @user.errors[:text]
+        assert user.valid?
+        user.text = '123'
+        assert_equal false, user.valid?
+        assert_equal ['only allows letters'], user.errors[:text]
+        user.text = nil
+        assert_equal false, user.valid?
+        assert_equal ['only allows letters', "can't be blank"], user.errors[:text]
+        user.text = ''
+        assert_equal false, user.valid?
+        assert_equal ['only allows letters', "can't be blank"], user.errors[:text]
       end
 
       it 'validate un-encrypted integer data with coercion' do
-        assert @user.valid?
-        @user.number = '123'
-        assert @user.valid?
-        assert_equal 123, @user.number
-        assert @user.valid?
-        @user.number = ''
-        assert_equal false, @user.valid?
-        assert_equal '', @user.number
-        assert_equal ["can't be blank"], @user.errors[:number]
-        @user.number = nil
-        assert_nil @user.number
-        assert_nil @user.encrypted_number
-        assert_equal false, @user.valid?
-        assert_equal ["can't be blank"], @user.errors[:number]
+        assert user.valid?
+        user.number = '123'
+        assert user.valid?
+        assert_equal 123, user.number
+        assert user.valid?
+        user.number = ''
+        assert_equal false, user.valid?
+        assert_equal '', user.number
+        assert_equal ["can't be blank"], user.errors[:number]
+        user.number = nil
+        assert_nil user.number
+        assert_nil user.encrypted_number
+        assert_equal false, user.valid?
+        assert_equal ["can't be blank"], user.errors[:number]
       end
     end
 
     describe 'with saved user' do
       before do
-        @user.save!
+        user.save!
       end
 
       after do
-        @user.destroy if @user
+        user&.destroy
       end
 
       it 'return correct data type before save' do
         u = User.new(integer_value: '5')
         assert_equal 5, u.integer_value
-        assert u.integer_value.kind_of?(Integer)
+        assert u.integer_value.is_a?(Integer)
       end
 
       it 'handle gsub! for non-encrypted_field' do
-        @user.name.gsub!('a', 'v')
-        new_name = @name.gsub('a', 'v')
-        assert_equal new_name, @user.name
-        @user.reload
-        assert_equal new_name, @user.name
+        user.name.tr!('a', 'v')
+        new_name = person_name.tr('a', 'v')
+        assert_equal new_name, user.name
+        user.reload
+        assert_equal new_name, user.name
       end
 
-      it "prevent gsub! on non-encrypted value of encrypted_field" do
+      it 'prevent gsub! on non-encrypted value of encrypted_field' do
         # can't modify frozen String
         assert_raises RuntimeError do
-          @user.bank_account_number.gsub!('5', '4')
+          user.bank_account_number.tr!('5', '4')
         end
       end
 
       describe '#reload' do
         it 'reverts changes' do
           new_bank_account_number   = '444444444'
-          @user.bank_account_number = new_bank_account_number
-          assert_equal new_bank_account_number, @user.bank_account_number
+          user.bank_account_number = new_bank_account_number
+          assert_equal new_bank_account_number, user.bank_account_number
 
           # Reload User model from the database
-          @user.reload
-          assert_equal @bank_account_number_encrypted, @user.encrypted_bank_account_number
-          assert_equal @bank_account_number, @user.bank_account_number
+          user.reload
+          assert_equal bank_account_number_encrypted, user.encrypted_bank_account_number
+          assert_equal bank_account_number, user.bank_account_number
         end
 
         it 'reverts changes to encrypted field' do
           new_bank_account_number             = '111111111'
           new_encrypted_bank_account_number   = SymmetricEncryption.encrypt(new_bank_account_number)
-          @user.encrypted_bank_account_number = new_encrypted_bank_account_number
-          assert_equal new_encrypted_bank_account_number, @user.encrypted_bank_account_number
-          assert_equal new_bank_account_number, @user.bank_account_number
+          user.encrypted_bank_account_number = new_encrypted_bank_account_number
+          assert_equal new_encrypted_bank_account_number, user.encrypted_bank_account_number
+          assert_equal new_bank_account_number, user.bank_account_number
 
           # Reload User model from the database
-          @user.reload
-          assert_equal @bank_account_number_encrypted, @user.encrypted_bank_account_number
-          assert_equal @bank_account_number, @user.bank_account_number
+          user.reload
+          assert_equal bank_account_number_encrypted, user.encrypted_bank_account_number
+          assert_equal bank_account_number, user.bank_account_number
         end
       end
 
       describe 'data types' do
         before do
-          @user_clone = User.find(@user.id)
+          @user_clone = User.find(user.id)
         end
 
         [
-          #@formatter:off
+          # @formatter:off
           {attribute: :integer_value,       klass: Integer,    value: INTEGER_VALUE,       new_value: 98},
           {attribute: :float_value,         klass: Float,      value: FLOAT_VALUE,         new_value: 45.4321},
-          {attribute: :decimal_value,       klass: BigDecimal, value: DECIMAL_VALUE,       new_value: BigDecimal.new('99.95'), coercible: '22.51'},
+          {attribute: :decimal_value,       klass: BigDecimal, value: DECIMAL_VALUE,       new_value: BigDecimal('99.95'), coercible: '22.51'},
           {attribute: :datetime_value,      klass: DateTime,   value: DATETIME_VALUE,      new_value: DateTime.new(1998, 10, 21, 8, 33, 28, '+5'), coercible: DATETIME_VALUE.to_time},
-          {attribute: :time_value,          klass: Time,       value: TIME_VALUE,          new_value: Time.new(2000, 01, 01, 22, 30, 00, "-04:00")},
-          {attribute: :date_value,          klass: Date,       value: DATE_VALUE,          new_value: Date.new(2027, 04, 02), coercible: DATE_VALUE.to_time},
+          {attribute: :time_value,          klass: Time,       value: TIME_VALUE,          new_value: Time.new(2000, 1, 1, 22, 30, 0, '-04:00')},
+          {attribute: :date_value,          klass: Date,       value: DATE_VALUE,          new_value: Date.new(2027, 4, 2), coercible: DATE_VALUE.to_time},
           {attribute: :true_value,          klass: TrueClass,  value: true,                new_value: false},
           {attribute: :false_value,         klass: FalseClass, value: false,               new_value: true},
           {attribute: :string_value,        klass: String,     value: STRING_VALUE,        new_value: 'Hello World'},
           {attribute: :long_string_value,   klass: String,     value: LONG_STRING_VALUE,   new_value: 'A Really long Hello World'},
           {attribute: :binary_string_value, klass: String,     value: BINARY_STRING_VALUE, new_value: "A new Non-UTF8 Binary \x92 string".force_encoding('BINARY')},
-          #@formatter:on
+          # @formatter:on
         ].each do |value_test|
           describe "#{value_test[:klass]} values" do
             before do
@@ -420,39 +463,39 @@ class ActiveRecordTest < Minitest::Test
               # Need to dup since minitest attempts to modify the decrypted value which is frozen
               val = val.dup if val.duplicable?
               assert_equal @value, val, @user_clone.attributes.ai
-              assert @user.send(@attribute).kind_of?(@klass)
+              assert user.send(@attribute).is_a?(@klass)
             end
 
             it 'coerce data type before save' do
               u = User.new(@attribute => @value)
               assert_equal @value, u.send(@attribute)
-              assert u.send(@attribute).kind_of?(@klass), "Value supposed to be coerced into #{@klass}, but is #{u.send(@attribute).class.name}"
+              assert u.send(@attribute).is_a?(@klass), "Value supposed to be coerced into #{@klass}, but is #{u.send(@attribute).class.name}"
             end
 
             it 'permit replacing value with nil' do
               @user_clone.send("#{@attribute}=".to_sym, nil)
               @user_clone.save!
 
-              @user.reload
-              assert_nil @user.send(@attribute)
-              assert_nil @user.send("encrypted_#{@attribute}".to_sym)
+              user.reload
+              assert_nil user.send(@attribute)
+              assert_nil user.send("encrypted_#{@attribute}".to_sym)
             end
 
             it 'permit replacing value with an empty string' do
               @user_clone.send("#{@attribute}=".to_sym, '')
               @user_clone.save!
 
-              @user.reload
-              assert_equal '', @user.send(@attribute)
-              assert_equal '', @user.send("encrypted_#{@attribute}".to_sym)
+              user.reload
+              assert_equal '', user.send(@attribute)
+              assert_equal '', user.send("encrypted_#{@attribute}".to_sym)
             end
 
             it 'permit replacing value' do
               @user_clone.send("#{@attribute}=".to_sym, @new_value)
               @user_clone.save!
 
-              @user.reload
-              val = @user.send(@attribute)
+              user.reload
+              val = user.send(@attribute)
               # Need to dup since minitest attempts to modify the decrypted value which is frozen
               val = val.dup if val.duplicable?
               assert_equal @new_value, val
@@ -461,89 +504,84 @@ class ActiveRecordTest < Minitest::Test
         end
 
         describe 'JSON Serialization' do
-          before do
-            # JSON Does not support symbols, so they will come back as strings
-            # Convert symbols to string in the test
-            @h.keys.each do |k|
-              @h[k.to_s] = @h[k]
-              @h.delete(k)
-            end
+          let :hash_data do
+            {'a' => 'A', 'b' => 'B'}
           end
 
           it 'return correct data type' do
-            assert_equal @h, @user_clone.data_json
-            assert @user.clone.data_json.kind_of?(Hash)
+            assert_equal hash_data, @user_clone.data_json
+            assert user.clone.data_json.is_a?(Hash)
           end
 
           it 'not coerce data type (leaves as hash) before save' do
-            u = User.new(data_json: @h)
-            assert_equal @h, u.data_json
-            assert u.data_json.kind_of?(Hash)
+            u = User.new(data_json: hash_data)
+            assert_equal hash_data, u.data_json
+            assert u.data_json.is_a?(Hash)
           end
 
           it 'permit replacing value with nil' do
             @user_clone.data_json = nil
             @user_clone.save!
 
-            @user.reload
-            assert_nil @user.data_json
-            assert_nil @user.encrypted_data_json
+            user.reload
+            assert_nil user.data_json
+            assert_nil user.encrypted_data_json
           end
 
           it 'permit replacing value' do
-            new_value             = @h.clone
+            new_value             = hash_data.clone
             new_value['c']        = 'C'
             @user_clone.data_json = new_value
             @user_clone.save!
 
-            @user.reload
-            assert_equal new_value, @user.data_json
+            user.reload
+            assert_equal new_value, user.data_json
           end
         end
 
         describe 'YAML Serialization' do
           it 'return correct data type' do
-            assert_equal @h, @user_clone.data_yaml
-            assert @user.clone.data_yaml.kind_of?(Hash)
+            assert_equal hash_data, @user_clone.data_yaml
+            assert user.clone.data_yaml.is_a?(Hash)
           end
 
           it 'not coerce data type (leaves as hash) before save' do
-            u = User.new(data_yaml: @h)
-            assert_equal @h, u.data_yaml
-            assert u.data_yaml.kind_of?(Hash)
+            u = User.new(data_yaml: hash_data)
+            assert_equal hash_data, u.data_yaml
+            assert u.data_yaml.is_a?(Hash)
           end
 
           it 'permit replacing value with nil' do
             @user_clone.data_yaml = nil
             @user_clone.save!
 
-            @user.reload
-            assert_nil @user.data_yaml
-            assert_nil @user.encrypted_data_yaml
+            user.reload
+            assert_nil user.data_yaml
+            assert_nil user.encrypted_data_yaml
           end
 
           it 'permit replacing value' do
-            new_value             = @h.clone
+            new_value             = hash_data.clone
             new_value[:c]         = 'C'
             @user_clone.data_yaml = new_value
             @user_clone.save!
 
-            @user.reload
-            assert_equal new_value, @user.data_yaml
+            user.reload
+            assert_equal new_value, user.data_yaml
           end
         end
       end
 
       describe 'changed?' do
         it 'return false if it was not changed' do
-          assert_equal false, @user.encrypted_bank_account_number_changed?
-          assert_equal false, @user.bank_account_number_changed?
+          assert_equal false, user.encrypted_bank_account_number_changed?
+          assert_equal false, user.bank_account_number_changed?
         end
 
         it 'return true if it was changed' do
-          @user.bank_account_number = '15424623'
-          assert @user.encrypted_bank_account_number_changed?
-          assert @user.bank_account_number_changed?
+          user.bank_account_number = '15424623'
+          assert user.encrypted_bank_account_number_changed?
+          assert user.bank_account_number_changed?
         end
       end
     end
@@ -553,7 +591,7 @@ class ActiveRecordTest < Minitest::Test
         UniqueUser.destroy_all
         @email      = 'whatever@not-unique.com'
         @username   = 'gibby007'
-        @user       = UniqueUser.create!(email: @email)
+        user       = UniqueUser.create!(email: @email)
         @email_user = UniqueUser.create!(username: @username)
       end
 
@@ -563,6 +601,5 @@ class ActiveRecordTest < Minitest::Test
         assert_equal 'has already been taken', duplicate.errors.messages[:encrypted_email].first
       end
     end
-
   end
 end