attr_encrypted 1.3.3 → 1.3.4

data/README.rdoc

@@ -1,4 +1,4 @@
-= attr_encrypted {<img src="https://travis-ci.org/attr-encrypted/attr_encrypted.png" />}[https://travis-ci.org/attr-encrypted/attr_encrypted]
+= attr_encrypted {<img src="https://travis-ci.org/attr-encrypted/attr_encrypted.png" />}[https://travis-ci.org/attr-encrypted/attr_encrypted] {<img src="https://codeclimate.com/github/attr-encrypted/attr_encrypted/badges/gpa.svg" />}[https://codeclimate.com/github/attr-encrypted/attr_encrypted]{<img src="https://codeclimate.com/github/attr-encrypted/attr_encrypted/badges/gpa.svg" />}[https://codeclimate.com/github/attr-encrypted/attr_encrypted]
 
 Generates attr_accessors that encrypt and decrypt attributes transparently
 
@@ -39,6 +39,48 @@ Encrypting attributes has never been easier:
 
 The <tt>attr_encrypted</tt> method is also aliased as <tt>attr_encryptor</tt> to conform to Ruby's <tt>attr_</tt> naming conventions. I should have called this project <tt>attr_encryptor</tt> but it was too late when I realized it ='(.
 
+=== Adding required columns via database migration
+
+By default, <tt>attr_encrypted</tt> uses the <tt>:single_iv_and_salt</tt>
+encryption mode for compatibility with previous versions of the gem. This mode
+uses a single IV and salt for each encrypted column. Create or modify your model
+to add a column with the <tt>encrypted_</tt> prefix (which can be modified, see
+below), e.g. <tt>encrypted_ssn</tt> via a migration like the following:
+
+  create_table :users do |t|
+    t.string :name
+    t.string :encrypted_ssn
+    t.timestamps
+  end
+
+For enhanced security, you can use the <tt>:per_attribute_iv_and_salt</tt> mode.
+This requires additional <tt>_salt</tt> and <tt>_iv</tt> columns with the
+<tt>encrypted_</tt> prefix as follows and generates a unique salt and IV per
+attribute:
+
+  create_table :users do |t|
+    t.string :name
+    t.string :encrypted_ssn
+    t.string :encrypted_ssn_salt
+    t.string :encrypted_ssn_iv
+    t.string :domain
+    t.timestamps
+  end
+
+This mode is enabled by specifying a value of <tt>:per_attribute_iv_and_salt</tt>
+via the <tt>:mode</tt> option as follows:
+
+  class User
+    attr_accessor :name
+    attr_encrypted :ssn, :key => 'a secret key', :mode => :per_attribute_iv_and_salt
+  end
+
+Note that there are alternatives to storing the IV and salt in separate columns:
+for example, see here[https://github.com/attr-encrypted/attr_encrypted/issues/118#issuecomment-45806629].
+Note that migration from the old encryption scheme to the new is nontrivial. One
+approach is described here[http://jjasonclark.com/switching_from_attr_encrypted_to_attr_encryptor],
+though these instructions describe the now-defunct <tt>attr_encryptor</tt> gem
+whose functionality has been merged into this project.
 
 === Specifying the encrypted attribute name
 

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
+require "bundler/gem_tasks"
 
 desc 'Test the attr_encrypted gem.'
 Rake::TestTask.new(:test) do |t|

data/lib/attr_encrypted.rb

@@ -127,7 +127,7 @@ module AttrEncrypted
       iv_name = "#{encrypted_attribute_name}_iv".to_sym
       salt_name = "#{encrypted_attribute_name}_salt".to_sym
 
-      instance_methods_as_symbols = instance_methods.collect { |method| method.to_sym }
+      instance_methods_as_symbols = attribute_instance_methods_as_symbols
       attr_reader encrypted_attribute_name unless instance_methods_as_symbols.include?(encrypted_attribute_name)
       attr_writer encrypted_attribute_name unless instance_methods_as_symbols.include?(:"#{encrypted_attribute_name}=")
 
@@ -156,6 +156,7 @@ module AttrEncrypted
       encrypted_attributes[attribute.to_sym] = options.merge(:attribute => encrypted_attribute_name)
     end
   end
+
   alias_method :attr_encryptor, :attr_encrypted
 
   # Default options to use with calls to <tt>attr_encrypted</tt>
@@ -302,7 +303,7 @@ module AttrEncrypted
 
       # Returns attr_encrypted options evaluated in the current object's scope for the attribute specified
       def evaluated_attr_encrypted_options_for(attribute)
-        if self.class.encrypted_attributes[attribute.to_sym][:mode] == :per_attribute_iv_and_salt
+        if evaluate_attr_encrypted_option(self.class.encrypted_attributes[attribute.to_sym][:mode]) == :per_attribute_iv_and_salt
           load_iv_for_attribute(attribute, self.class.encrypted_attributes[attribute.to_sym][:algorithm])
           load_salt_for_attribute(attribute)
         end
@@ -344,6 +345,13 @@ module AttrEncrypted
         self.class.encrypted_attributes[attribute.to_sym] = self.class.encrypted_attributes[attribute.to_sym].merge(:salt => salt)
       end
   end
+
+  protected
+
+  def attribute_instance_methods_as_symbols
+    instance_methods.collect { |method| method.to_sym }
+  end
+
 end
 
 Object.extend AttrEncrypted

data/lib/attr_encrypted/adapters/active_record.rb

@@ -4,6 +4,17 @@ if defined?(ActiveRecord::Base)
       module ActiveRecord
         def self.extended(base) # :nodoc:
           base.class_eval do
+
+            # https://github.com/attr-encrypted/attr_encrypted/issues/68
+            def reload_with_attr_encrypted(*args, &block)
+              result = reload_without_attr_encrypted(*args, &block)
+              self.class.encrypted_attributes.keys.each do |attribute_name|
+                instance_variable_set("@#{attribute_name}", nil)
+              end
+              result
+            end
+            alias_method_chain :reload, :attr_encrypted
+
             attr_encrypted_options[:encode] = true
             class << self
               alias_method :attr_encryptor, :attr_encrypted
@@ -13,10 +24,9 @@ if defined?(ActiveRecord::Base)
 
             def perform_attribute_assignment(method, new_attributes, *args)
               return if new_attributes.blank?
-              attributes = new_attributes.respond_to?(:with_indifferent_access) ? new_attributes.with_indifferent_access : new_attributes.symbolize_keys
-              encrypted_attributes = self.class.encrypted_attributes.keys
-              self.send method, attributes.except(*encrypted_attributes), *args
-              self.send method, attributes.slice(*encrypted_attributes), *args
+
+              send method, new_attributes.reject { |k, _|  self.class.encrypted_attributes.key?(k.to_sym) }, *args
+              send method, new_attributes.reject { |k, _| !self.class.encrypted_attributes.key?(k.to_sym) }, *args
             end
             private :perform_attribute_assignment
 
@@ -25,27 +35,35 @@ if defined?(ActiveRecord::Base)
                 perform_attribute_assignment :assign_attributes_without_attr_encrypted, *args
               end
               alias_method_chain :assign_attributes, :attr_encrypted
-            else
-              def attributes_with_attr_encrypted=(*args)
-                perform_attribute_assignment :attributes_without_attr_encrypted=, *args
-              end
-              alias_method_chain :attributes=, :attr_encrypted
             end
+
+            def attributes_with_attr_encrypted=(*args)
+              perform_attribute_assignment :attributes_without_attr_encrypted=, *args
+            end
+            alias_method_chain :attributes=, :attr_encrypted
           end
         end
 
         protected
 
-          # Ensures the attribute methods for db fields have been defined before calling the original 
           # <tt>attr_encrypted</tt> method
           def attr_encrypted(*attrs)
-            define_attribute_methods rescue nil
             super
-            undefine_attribute_methods
             attrs.reject { |attr| attr.is_a?(Hash) }.each { |attr| alias_method "#{attr}_before_type_cast", attr }
           end
 
-          # Allows you to use dynamic methods like <tt>find_by_email</tt> or <tt>scoped_by_email</tt> for 
+          def attribute_instance_methods_as_symbols
+            # We add accessor methods of the db columns to the list of instance
+            # methods returned to let ActiveRecord define the accessor methods
+            # for the db columns
+            if table_exists?
+              columns_hash.keys.inject(super) {|instance_methods, column_name| instance_methods.concat [column_name.to_sym, :"#{column_name}="]}
+            else
+              super
+            end
+          end
+
+          # Allows you to use dynamic methods like <tt>find_by_email</tt> or <tt>scoped_by_email</tt> for
           # encrypted attributes
           #
           # NOTE: This only works when the <tt>:key</tt> option is specified as a string (see the README)
@@ -80,4 +98,4 @@ if defined?(ActiveRecord::Base)
   end
 
   ActiveRecord::Base.extend AttrEncrypted::Adapters::ActiveRecord
-end
+end

data/lib/attr_encrypted/version.rb

@@ -3,7 +3,7 @@ module AttrEncrypted
   module Version
     MAJOR = 1
     MINOR = 3
-    PATCH = 3
+    PATCH = 4
 
     # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and <tt>PATCH</tt> with <tt>'.'</tt>
     #

data/test/active_record_test.rb

@@ -25,6 +25,9 @@ def create_tables
         t.string :encrypted_password
         t.boolean :is_admin
       end
+      create_table :prime_ministers do |t|
+        t.string :encrypted_name
+      end
     end
   end
 end
@@ -70,6 +73,11 @@ class PersonWithValidation < Person
   validates_presence_of :email
 end
 
+class PersonWithProcMode < Person
+  attr_encrypted :email,       :key => SECRET_KEY, :mode => Proc.new { :per_attribute_iv_and_salt }
+  attr_encrypted :credentials, :key => SECRET_KEY, :mode => Proc.new { :single_iv_and_salt }
+end
+
 class Account < ActiveRecord::Base
   attr_accessor :key
   attr_encrypted :password, :key => Proc.new {|account| account.key}
@@ -92,7 +100,11 @@ class PersonUsingAlias < ActiveRecord::Base
   attr_encryptor :email, :key => 'a secret key'
 end
 
-class ActiveRecordTest < Test::Unit::TestCase
+class PrimeMinister < ActiveRecord::Base
+  attr_encrypted :name, :marshal => true, :key => 'SECRET_KEY'
+end
+
+class ActiveRecordTest < Minitest::Test
 
   def setup
     ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
@@ -102,15 +114,15 @@ class ActiveRecordTest < Test::Unit::TestCase
 
   def test_should_encrypt_email
     @person = Person.create :email => 'test@example.com'
-    assert_not_nil @person.encrypted_email
-    assert_not_equal @person.email, @person.encrypted_email
+    refute_nil @person.encrypted_email
+    refute_equal @person.email, @person.encrypted_email
     assert_equal @person.email, Person.find(:first).email
   end
 
   def test_should_marshal_and_encrypt_credentials
     @person = Person.create
-    assert_not_nil @person.encrypted_credentials
-    assert_not_equal @person.credentials, @person.encrypted_credentials
+    refute_nil @person.encrypted_credentials
+    refute_equal @person.credentials, @person.encrypted_credentials
     assert_equal @person.credentials, Person.find(:first).credentials
   end
 
@@ -127,7 +139,7 @@ class ActiveRecordTest < Test::Unit::TestCase
   def test_should_encrypt_decrypt_with_iv
     @person = Person.create :email => 'test@example.com'
     @person2 = Person.find(@person.id)
-    assert_not_nil @person2.encrypted_email_iv
+    refute_nil @person2.encrypted_email_iv
     assert_equal 'test@example.com', @person2.email
   end
 
@@ -142,6 +154,16 @@ class ActiveRecordTest < Test::Unit::TestCase
     Account.create!(:password => "password" , :key => SECRET_KEY)
   end
 
+  def test_should_set_attributes_regardless_of_arguments_order
+    Account.new.attributes = { :password => "password" , :key => SECRET_KEY }
+  end
+
+  def test_should_preserve_hash_key_type
+    hash = { :foo => 'bar' }
+    account = Account.create!(:key => hash)
+    assert_equal account.key, hash
+  end
+
   if ::ActiveRecord::VERSION::STRING > "4.0"
     def test_should_assign_attributes
       @user = UserWithProtectedAttribute.new :login => 'login', :is_admin => false
@@ -157,13 +179,13 @@ class ActiveRecordTest < Test::Unit::TestCase
 
     def test_should_raise_exception_if_not_permitted
       @user = UserWithProtectedAttribute.new :login => 'login', :is_admin => false
-      assert_raise ActiveModel::ForbiddenAttributesError do
+      assert_raises ActiveModel::ForbiddenAttributesError do
         @user.attributes = ActionController::Parameters.new(:login => 'modified', :is_admin => true)
       end
     end
 
     def test_should_raise_exception_on_init_if_not_permitted
-      assert_raise ActiveModel::ForbiddenAttributesError do
+      assert_raises ActiveModel::ForbiddenAttributesError do
         @user = UserWithProtectedAttribute.new ActionController::Parameters.new(:login => 'modified', :is_admin => true)
       end
     end
@@ -196,6 +218,22 @@ class ActiveRecordTest < Test::Unit::TestCase
     assert_nil(@person.attributes = nil)
   end
 
+  def test_should_allow_proc_based_mode
+    @person = PersonWithProcMode.create :email => 'test@example.com', :credentials => 'password123'
+
+    # Email is :per_attribute_iv_and_salt
+    assert_equal @person.class.encrypted_attributes[:email][:mode].class, Proc
+    assert_equal @person.class.encrypted_attributes[:email][:mode].call, :per_attribute_iv_and_salt
+    refute_nil @person.encrypted_email_salt
+    refute_nil @person.encrypted_email_iv
+
+    # Credentials is :single_iv_and_salt
+    assert_equal @person.class.encrypted_attributes[:credentials][:mode].class, Proc
+    assert_equal @person.class.encrypted_attributes[:credentials][:mode].call, :single_iv_and_salt
+    assert_nil @person.encrypted_credentials_salt
+    assert_nil @person.encrypted_credentials_iv
+  end
+
   if ::ActiveRecord::VERSION::STRING > "3.1"
     def test_should_allow_assign_attributes_with_nil
       @person = Person.new
@@ -203,15 +241,26 @@ class ActiveRecordTest < Test::Unit::TestCase
     end
   end
 
-  class TestAlias < Test::Unit::TestCase
-    def test_that_alias_encrypts_column
-      user = PersonUsingAlias.new
-      user.email = 'test@example.com'
-      user.save
+  def test_that_alias_encrypts_column
+    user = PersonUsingAlias.new
+    user.email = 'test@example.com'
+    user.save
 
-      assert_not_nil user.encrypted_email
-      assert_not_equal user.email, user.encrypted_email
-      assert_equal user.email, PersonUsingAlias.find(:first).email
-    end
+    refute_nil user.encrypted_email
+    refute_equal user.email, user.encrypted_email
+    assert_equal user.email, PersonUsingAlias.find(:first).email
+  end
+
+  # See https://github.com/attr-encrypted/attr_encrypted/issues/68
+  def test_should_invalidate_virtual_attributes_on_reload
+    pm = PrimeMinister.new(:name => 'Winston Churchill')
+    pm.save!
+    assert_equal 'Winston Churchill', pm.name
+    pm.name = 'Neville Chamberlain'
+    assert_equal 'Neville Chamberlain', pm.name
+
+    result = pm.reload
+    assert_equal pm, result
+    assert_equal 'Winston Churchill', pm.name
   end
 end

data/test/attr_encrypted_test.rb

@@ -53,7 +53,7 @@ class SomeOtherClass
   end
 end
 
-class AttrEncryptedTest < Test::Unit::TestCase
+class AttrEncryptedTest < Minitest::Test
 
   def test_should_store_email_in_encrypted_attributes
     assert User.encrypted_attributes.include?(:email)
@@ -68,7 +68,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
   end
 
   def test_attr_encrypted_should_not_use_the_same_attribute_name_for_two_attributes_in_the_same_line
-    assert_not_equal User.encrypted_attributes[:email][:attribute], User.encrypted_attributes[:without_encoding][:attribute]
+    refute_equal User.encrypted_attributes[:email][:attribute], User.encrypted_attributes[:without_encoding][:attribute]
   end
 
   def test_attr_encrypted_should_return_false_for_salt
@@ -96,15 +96,15 @@ class AttrEncryptedTest < Test::Unit::TestCase
   end
 
   def test_should_encrypt_email
-    assert_not_nil User.encrypt_email('test@example.com')
-    assert_not_equal 'test@example.com', User.encrypt_email('test@example.com')
+    refute_nil User.encrypt_email('test@example.com')
+    refute_equal 'test@example.com', User.encrypt_email('test@example.com')
   end
 
   def test_should_encrypt_email_when_modifying_the_attr_writer
     @user = User.new
     assert_nil @user.encrypted_email
     @user.email = 'test@example.com'
-    assert_not_nil @user.encrypted_email
+    refute_nil @user.encrypted_email
     assert_equal User.encrypt_email('test@example.com'), @user.encrypted_email
   end
 
@@ -118,7 +118,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
 
   def test_should_decrypt_email
     encrypted_email = User.encrypt_email('test@example.com')
-    assert_not_equal 'test@test.com', encrypted_email
+    refute_equal 'test@test.com', encrypted_email
     assert_equal 'test@example.com', User.decrypt_email(encrypted_email)
   end
 
@@ -152,7 +152,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
   def test_should_encrypt_with_marshaling
     @user = User.new
     @user.with_marshaling = [1, 2, 3]
-    assert_not_nil @user.encrypted_with_marshaling
+    refute_nil @user.encrypted_with_marshaling
   end
 
   def test_should_use_custom_encryptor_and_crypt_method_names_and_arguments
@@ -163,7 +163,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     assert_nil @user.ssn_encrypted
     @user.ssn = 'testing'
-    assert_not_nil @user.ssn_encrypted
+    refute_nil @user.ssn_encrypted
     encrypted =  Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.ssn_encrypted_iv.unpack("m").first, :salt => @user.ssn_encrypted_salt )
     assert_equal encrypted, @user.ssn_encrypted
   end
@@ -172,7 +172,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     assert_nil @user.crypted_password_test
     @user.password = 'testing'
-    assert_not_nil @user.crypted_password_test
+    refute_nil @user.crypted_password_test
     encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.crypted_password_test_iv.unpack("m").first, :salt =>  @user.crypted_password_test_salt)
     assert_equal encrypted, @user.crypted_password_test
   end
@@ -181,7 +181,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     assert_nil @user.crypted_password_test
     @user.password = 'testing'
-    assert_not_nil @user.crypted_password_test
+    refute_nil @user.crypted_password_test
     encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.crypted_password_test_iv.unpack("m").first, :salt => @user.crypted_password_test_salt)
     assert_equal encrypted, @user.crypted_password_test
   end
@@ -224,7 +224,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     assert_nil @user.encrypted_with_true_if
     @user.with_true_if = 'testing'
-    assert_not_nil @user.encrypted_with_true_if
+    refute_nil @user.encrypted_with_true_if
     encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.encrypted_with_true_if_iv.unpack("m").first, :salt => @user.encrypted_with_true_if_salt)
     assert_equal encrypted, @user.encrypted_with_true_if
   end
@@ -233,7 +233,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     assert_nil @user.encrypted_with_false_if
     @user.with_false_if = 'testing'
-    assert_not_nil @user.encrypted_with_false_if
+    refute_nil @user.encrypted_with_false_if
     assert_equal 'testing', @user.encrypted_with_false_if
   end
 
@@ -241,7 +241,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     assert_nil @user.encrypted_with_false_unless
     @user.with_false_unless = 'testing'
-    assert_not_nil @user.encrypted_with_false_unless
+    refute_nil @user.encrypted_with_false_unless
     encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.encrypted_with_false_unless_iv.unpack("m").first, :salt => @user.encrypted_with_false_unless_salt)
     assert_equal encrypted,  @user.encrypted_with_false_unless
   end
@@ -250,7 +250,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     assert_nil @user.encrypted_with_true_unless
     @user.with_true_unless = 'testing'
-    assert_not_nil @user.encrypted_with_true_unless
+    refute_nil @user.encrypted_with_true_unless
     assert_equal 'testing', @user.encrypted_with_true_unless
   end
 
@@ -263,7 +263,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user.with_if_changed = "encrypt_stuff"
     @user.stubs(:instance_variable_get).returns(nil)
     @user.stubs(:instance_variable_set).raises("BadStuff")
-    assert_raise RuntimeError do
+    assert_raises RuntimeError do
       @user.with_if_changed
     end
 
@@ -293,7 +293,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user = User.new
     @user.email = 'email@example.com'
     @user.password = 'p455w0rd'
-    assert_not_equal @user.encrypted_email_iv, @user.crypted_password_test_iv
+    refute_equal @user.encrypted_email_iv, @user.crypted_password_test_iv
   end
 
   def test_should_vary_iv_per_instance
@@ -301,14 +301,14 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user1.email = 'email@example.com'
     @user2 = User.new
     @user2.email = 'email@example.com'
-    assert_not_equal @user1.encrypted_email_iv, @user2.encrypted_email_iv
+    refute_equal @user1.encrypted_email_iv, @user2.encrypted_email_iv
   end
 
   def test_should_vary_salt_per_attribute
     @user = User.new
     @user.email = 'email@example.com'
     @user.password = 'p455w0rd'
-    assert_not_equal @user.encrypted_email_salt, @user.crypted_password_test_salt
+    refute_equal @user.encrypted_email_salt, @user.crypted_password_test_salt
   end
 
   def test_should_vary_salt_per_instance
@@ -316,7 +316,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user1.email = 'email@example.com'
     @user2 = User.new
     @user2.email = 'email@example.com'
-    assert_not_equal @user1.encrypted_email_salt, @user2.encrypted_email_salt
+    refute_equal @user1.encrypted_email_salt, @user2.encrypted_email_salt
   end
 
   def test_should_decrypt_second_record

data/test/compatibility_test.rb

@@ -5,7 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
 # migrating to new versions of this gem. This ensures that future versions of
 # this gem will retain backwards compatibility with data generated by earlier
 # versions.
-class CompatibilityTest < Test::Unit::TestCase
+class CompatibilityTest < Minitest::Test
   class NonmarshallingPet < ActiveRecord::Base
     PET_NICKNAME_SALT = Digest::SHA256.hexdigest('my-really-really-secret-pet-nickname-salt')
     PET_NICKNAME_KEY = 'my-really-really-secret-pet-nickname-key'

data/test/data_mapper_test.rb

@@ -27,7 +27,7 @@ end
 
 DataMapper.auto_migrate!
 
-class DataMapperTest < Test::Unit::TestCase
+class DataMapperTest < Minitest::Test
 
   def setup
     Client.all.each(&:destroy)
@@ -36,16 +36,16 @@ class DataMapperTest < Test::Unit::TestCase
   def test_should_encrypt_email
     @client = Client.new :email => 'test@example.com'
     assert @client.save
-    assert_not_nil @client.encrypted_email
-    assert_not_equal @client.email, @client.encrypted_email
+    refute_nil @client.encrypted_email
+    refute_equal @client.email, @client.encrypted_email
     assert_equal @client.email, Client.first.email
   end
 
   def test_should_marshal_and_encrypt_credentials
     @client = Client.new
     assert @client.save
-    assert_not_nil @client.encrypted_credentials
-    assert_not_equal @client.credentials, @client.encrypted_credentials
+    refute_nil @client.encrypted_credentials
+    refute_equal @client.credentials, @client.encrypted_credentials
     assert_equal @client.credentials, Client.first.credentials
     assert Client.first.credentials.is_a?(Hash)
   end

data/test/legacy_active_record_test.rb

@@ -45,7 +45,7 @@ class LegacyPersonWithValidation < LegacyPerson
   validates_uniqueness_of :encrypted_email
 end
 
-class LegacyActiveRecordTest < Test::Unit::TestCase
+class LegacyActiveRecordTest < Minitest::Test
 
   def setup
     ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
@@ -61,15 +61,15 @@ class LegacyActiveRecordTest < Test::Unit::TestCase
 
   def test_should_encrypt_email
     @person = LegacyPerson.create :email => 'test@example.com'
-    assert_not_nil @person.encrypted_email
-    assert_not_equal @person.email, @person.encrypted_email
+    refute_nil @person.encrypted_email
+    refute_equal @person.email, @person.encrypted_email
     assert_equal @person.email, LegacyPerson.find(:first).email
   end
 
   def test_should_marshal_and_encrypt_credentials
     @person = LegacyPerson.create
-    assert_not_nil @person.encrypted_credentials
-    assert_not_equal @person.credentials, @person.encrypted_credentials
+    refute_nil @person.encrypted_credentials
+    refute_equal @person.credentials, @person.encrypted_credentials
     assert_equal @person.credentials, LegacyPerson.find(:first).credentials
   end
 

data/test/legacy_attr_encrypted_test.rb

@@ -48,7 +48,7 @@ class LegacySomeOtherClass
   end
 end
 
-class LegacyAttrEncryptedTest < Test::Unit::TestCase
+class LegacyAttrEncryptedTest < Minitest::Test
 
   def test_should_store_email_in_encrypted_attributes
     assert LegacyUser.encrypted_attributes.include?(:email)
@@ -63,7 +63,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
   end
 
   def test_attr_encrypted_should_not_use_the_same_attribute_name_for_two_attributes_in_the_same_line
-    assert_not_equal LegacyUser.encrypted_attributes[:email][:attribute], LegacyUser.encrypted_attributes[:without_encoding][:attribute]
+    refute_equal LegacyUser.encrypted_attributes[:email][:attribute], LegacyUser.encrypted_attributes[:without_encoding][:attribute]
   end
 
   def test_attr_encrypted_should_return_false_for_salt
@@ -91,15 +91,15 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
   end
 
   def test_should_encrypt_email
-    assert_not_nil LegacyUser.encrypt_email('test@example.com')
-    assert_not_equal 'test@example.com', LegacyUser.encrypt_email('test@example.com')
+    refute_nil LegacyUser.encrypt_email('test@example.com')
+    refute_equal 'test@example.com', LegacyUser.encrypt_email('test@example.com')
   end
 
   def test_should_encrypt_email_when_modifying_the_attr_writer
     @user = LegacyUser.new
     assert_nil @user.encrypted_email
     @user.email = 'test@example.com'
-    assert_not_nil @user.encrypted_email
+    refute_nil @user.encrypted_email
     assert_equal LegacyUser.encrypt_email('test@example.com'), @user.encrypted_email
   end
 
@@ -113,7 +113,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
 
   def test_should_decrypt_email
     encrypted_email = LegacyUser.encrypt_email('test@example.com')
-    assert_not_equal 'test@test.com', encrypted_email
+    refute_equal 'test@test.com', encrypted_email
     assert_equal 'test@example.com', LegacyUser.decrypt_email(encrypted_email)
   end
 
@@ -153,7 +153,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
   def test_should_encrypt_with_marshaling
     @user = LegacyUser.new
     @user.with_marshaling = [1, 2, 3]
-    assert_not_nil @user.encrypted_with_marshaling
+    refute_nil @user.encrypted_with_marshaling
     assert_equal LegacyUser.encrypt_with_marshaling([1, 2, 3]), @user.encrypted_with_marshaling
   end
 
@@ -173,7 +173,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user = LegacyUser.new
     assert_nil @user.ssn_encrypted
     @user.ssn = 'testing'
-    assert_not_nil @user.ssn_encrypted
+    refute_nil @user.ssn_encrypted
     assert_equal Encryptor.encrypt(:value => 'testing', :key => @user.salt), @user.ssn_encrypted
   end
 
@@ -181,7 +181,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user = LegacyUser.new
     assert_nil @user.crypted_password_test
     @user.password = 'testing'
-    assert_not_nil @user.crypted_password_test
+    refute_nil @user.crypted_password_test
     assert_equal Encryptor.encrypt(:value => 'testing', :key => 'LegacyUser'), @user.crypted_password_test
   end
 
@@ -189,7 +189,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user = LegacyUser.new
     assert_nil @user.crypted_password_test
     @user.password = 'testing'
-    assert_not_nil @user.crypted_password_test
+    refute_nil @user.crypted_password_test
     assert_equal Encryptor.encrypt(:value => 'testing', :key => 'LegacyUser'), @user.crypted_password_test
   end
 
@@ -231,7 +231,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user = LegacyUser.new
     assert_nil @user.encrypted_with_true_if
     @user.with_true_if = 'testing'
-    assert_not_nil @user.encrypted_with_true_if
+    refute_nil @user.encrypted_with_true_if
     assert_equal Encryptor.encrypt(:value => 'testing', :key => 'secret key'), @user.encrypted_with_true_if
   end
 
@@ -239,7 +239,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user = LegacyUser.new
     assert_nil @user.encrypted_with_false_if
     @user.with_false_if = 'testing'
-    assert_not_nil @user.encrypted_with_false_if
+    refute_nil @user.encrypted_with_false_if
     assert_equal 'testing', @user.encrypted_with_false_if
   end
 
@@ -247,7 +247,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user = LegacyUser.new
     assert_nil @user.encrypted_with_false_unless
     @user.with_false_unless = 'testing'
-    assert_not_nil @user.encrypted_with_false_unless
+    refute_nil @user.encrypted_with_false_unless
     assert_equal Encryptor.encrypt(:value => 'testing', :key => 'secret key'), @user.encrypted_with_false_unless
   end
 
@@ -255,7 +255,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user = LegacyUser.new
     assert_nil @user.encrypted_with_true_unless
     @user.with_true_unless = 'testing'
-    assert_not_nil @user.encrypted_with_true_unless
+    refute_nil @user.encrypted_with_true_unless
     assert_equal 'testing', @user.encrypted_with_true_unless
   end
 
@@ -268,7 +268,7 @@ class LegacyAttrEncryptedTest < Test::Unit::TestCase
     @user.with_if_changed = "encrypt_stuff"
     @user.stubs(:instance_variable_get).returns(nil)
     @user.stubs(:instance_variable_set).raises("BadStuff")
-    assert_raise RuntimeError do 
+    assert_raises RuntimeError do
       @user.with_if_changed
     end
 

data/test/legacy_compatibility_test.rb

@@ -5,7 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
 # migrating to new versions of this gem. This ensures that future versions of
 # this gem will retain backwards compatibility with data generated by earlier
 # versions.
-class LegacyCompatibilityTest < Test::Unit::TestCase
+class LegacyCompatibilityTest < Minitest::Test
   class LegacyNonmarshallingPet < ActiveRecord::Base
     PET_NICKNAME_SALT = Digest::SHA256.hexdigest('my-really-really-secret-pet-nickname-salt')
     PET_NICKNAME_KEY = 'my-really-really-secret-pet-nickname-key'

data/test/legacy_data_mapper_test.rb

@@ -22,7 +22,7 @@ end
 
 DataMapper.auto_migrate!
 
-class LegacyDataMapperTest < Test::Unit::TestCase
+class LegacyDataMapperTest < Minitest::Test
 
   def setup
     LegacyClient.all.each(&:destroy)
@@ -31,16 +31,16 @@ class LegacyDataMapperTest < Test::Unit::TestCase
   def test_should_encrypt_email
     @client = LegacyClient.new :email => 'test@example.com'
     assert @client.save
-    assert_not_nil @client.encrypted_email
-    assert_not_equal @client.email, @client.encrypted_email
+    refute_nil @client.encrypted_email
+    refute_equal @client.email, @client.encrypted_email
     assert_equal @client.email, LegacyClient.first.email
   end
 
   def test_should_marshal_and_encrypt_credentials
     @client = LegacyClient.new
     assert @client.save
-    assert_not_nil @client.encrypted_credentials
-    assert_not_equal @client.credentials, @client.encrypted_credentials
+    refute_nil @client.encrypted_credentials
+    refute_equal @client.credentials, @client.encrypted_credentials
     assert_equal @client.credentials, LegacyClient.first.credentials
     assert LegacyClient.first.credentials.is_a?(Hash)
   end

data/test/legacy_sequel_test.rb

@@ -18,7 +18,7 @@ class LegacyHuman < Sequel::Model(:legacy_humans)
   end
 end
 
-class LegacySequelTest < Test::Unit::TestCase
+class LegacySequelTest < Minitest::Test
 
   def setup
     LegacyHuman.all.each(&:destroy)
@@ -27,16 +27,16 @@ class LegacySequelTest < Test::Unit::TestCase
   def test_should_encrypt_email
     @human = LegacyHuman.new :email => 'test@example.com'
     assert @human.save
-    assert_not_nil @human.encrypted_email
-    assert_not_equal @human.email, @human.encrypted_email
+    refute_nil @human.encrypted_email
+    refute_equal @human.email, @human.encrypted_email
     assert_equal @human.email, LegacyHuman.first.email
   end
 
   def test_should_marshal_and_encrypt_credentials
     @human = LegacyHuman.new
     assert @human.save
-    assert_not_nil @human.encrypted_credentials
-    assert_not_equal @human.credentials, @human.encrypted_credentials
+    refute_nil @human.encrypted_credentials
+    refute_equal @human.credentials, @human.encrypted_credentials
     assert_equal @human.credentials, LegacyHuman.first.credentials
     assert LegacyHuman.first.credentials.is_a?(Hash)
   end

data/test/sequel_test.rb

@@ -22,7 +22,7 @@ class Human < Sequel::Model(:humans)
   end
 end
 
-class SequelTest < Test::Unit::TestCase
+class SequelTest < Minitest::Test
 
   def setup
     Human.all.each(&:destroy)
@@ -31,8 +31,8 @@ class SequelTest < Test::Unit::TestCase
   def test_should_encrypt_email
     @human = Human.new :email => 'test@example.com'
     assert @human.save
-    assert_not_nil @human.encrypted_email
-    assert_not_equal @human.email, @human.encrypted_email
+    refute_nil @human.encrypted_email
+    refute_equal @human.email, @human.encrypted_email
     assert_equal @human.email, Human.first.email
   end
 
@@ -40,8 +40,8 @@ class SequelTest < Test::Unit::TestCase
 
     @human = Human.new :credentials => { :username => 'example', :password => 'test' }
     assert @human.save
-    assert_not_nil @human.encrypted_credentials
-    assert_not_equal @human.credentials, @human.encrypted_credentials
+    refute_nil @human.encrypted_credentials
+    refute_equal @human.credentials, @human.encrypted_credentials
     assert_equal @human.credentials, Human.first.credentials
     assert Human.first.credentials.is_a?(Hash)
   end

data/test/test_helper.rb

@@ -12,7 +12,11 @@ if RUBY_VERSION >= '1.9.3'
   end
 end
 
-require 'test/unit'
+require 'minitest'
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'minitest/autorun'
 require 'digest/sha2'
 require 'rubygems'
 gem 'activerecord', ENV['ACTIVE_RECORD_VERSION'] if ENV['ACTIVE_RECORD_VERSION']

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: attr_encrypted
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.4
   prerelease: 
 platform: ruby
 authors:
 - Sean Huber
 - S. Brent Faulkner
 - William Monk
+- Stephen Aghaulor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-27 00:00:00.000000000 Z
+date: 2015-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: encryptor
@@ -45,6 +46,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: datamapper
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +195,7 @@ email:
 - shuber@huberry.com
 - sbfaulkner@gmail.com
 - billy.monk@gmail.com
+- saghaulor@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -218,15 +236,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1997953751590493696
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1997953751590493696
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.23.2
 signing_key: 
 specification_version: 3
 summary: Encrypt and decrypt attributes