ibm_db 5.6.1 → 5.7.0

data/test/cases/dup_test.rb

@@ -4,10 +4,11 @@ require "cases/helper"
 require "models/reply"
 require "models/topic"
 require "models/movie"
+require "models/car"
 
 module ActiveRecord
   class DupTest < ActiveRecord::TestCase
-    fixtures :topics
+    fixtures :topics, :cars
 
     def test_dup
       assert_not_predicate Topic.new.freeze.dup, :frozen?
@@ -25,7 +26,7 @@ module ActiveRecord
       topic.readonly!
 
       duped = topic.dup
-      assert duped.readonly?, "should be readonly"
+      assert_predicate duped, :readonly?, "should be readonly"
     end
 
     def test_dup_not_persisted
@@ -33,7 +34,7 @@ module ActiveRecord
       duped = topic.dup
 
       assert_not duped.persisted?, "topic not persisted"
-      assert duped.new_record?, "topic is new"
+      assert_predicate duped, :new_record?, "topic is new"
     end
 
     def test_dup_not_previously_new_record
@@ -118,6 +119,27 @@ module ActiveRecord
       assert_not_nil new_topic.created_at
     end
 
+    def test_dup_locking_column_is_cleared
+      car = Car.first
+      car.touch
+      assert_not_equal 0, car.lock_version
+
+      car.lock_version = 1000
+
+      new_car = car.dup
+      assert_equal 0, new_car.lock_version
+    end
+
+    def test_dup_locking_column_is_not_dirty
+      car = Car.first
+      car.touch
+      assert_not_equal 0, car.lock_version
+
+      car.lock_version += 1
+      new_car = car.dup
+      assert_not_predicate new_car, :lock_version_changed?
+    end
+
     def test_dup_after_initialize_callbacks
       topic = Topic.new
       assert Topic.after_initialize_called
@@ -145,7 +167,7 @@ module ActiveRecord
 
     def test_dup_with_default_scope
       prev_default_scopes = Topic.default_scopes
-      Topic.default_scopes = [proc { Topic.where(approved: true) }]
+      Topic.default_scopes = [ActiveRecord::Scoping::DefaultScope.new(proc { Topic.where(approved: true) })]
       topic = Topic.new(approved: false)
       assert_not topic.dup.approved?, "should not be overridden by default scopes"
     ensure
@@ -153,8 +175,6 @@ module ActiveRecord
     end
 
     def test_dup_without_primary_key
-      skip if current_adapter?(:OracleAdapter) or current_adapter?(:IBM_DBAdapter)
-
       klass = Class.new(ActiveRecord::Base) do
         self.table_name = "parrots_pirates"
       end

data/test/cases/encryption/cipher/aes256_gcm_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::Aes256GcmTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @key = ActiveRecord::Encryption.key_generator.generate_random_key length: ActiveRecord::Encryption::Cipher::Aes256Gcm.key_length
+    @cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key)
+  end
+
+  test "encrypts strings" do
+    assert_cipher_encrypts(@cipher, "Some clear text")
+  end
+
+  test "works with empty strings" do
+    assert_cipher_encrypts(@cipher, "")
+  end
+
+  test "uses non-deterministic encryption by default" do
+    assert_not_equal @cipher.encrypt("Some text").payload, @cipher.encrypt("Some text").payload
+  end
+
+  test "in deterministic mode, it generates the same ciphertext for the same inputs" do
+    cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key, deterministic: true)
+
+    assert_cipher_encrypts(cipher, "Some clear text")
+
+    assert_equal cipher.encrypt("Some text").payload, cipher.encrypt("Some text").payload
+    assert_not_equal cipher.encrypt("Some text").payload, cipher.encrypt("Some other text").payload
+  end
+
+  test "it generates different ivs for different ciphertexts" do
+    cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key, deterministic: true)
+
+    assert_equal cipher.encrypt("Some text").headers.iv, cipher.encrypt("Some text").headers.iv
+    assert_not_equal cipher.encrypt("Some text").headers.iv, cipher.encrypt("Some other text").headers.iv
+  end
+
+  test "inspect_does not show secrets" do
+    cipher = ActiveRecord::Encryption::Cipher::Aes256Gcm.new(@key)
+    assert_match(/\A#<ActiveRecord::Encryption::Cipher::Aes256Gcm:0x[0-9a-f]+>\z/, cipher.inspect)
+  end
+
+  private
+    def assert_cipher_encrypts(cipher, content_to_encrypt)
+      encrypted_content = cipher.encrypt(content_to_encrypt)
+      assert_not_equal content_to_encrypt, encrypted_content
+      assert_equal content_to_encrypt, cipher.decrypt(encrypted_content)
+    end
+end

data/test/cases/encryption/cipher_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::CipherTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @cipher = ActiveRecord::Encryption::Cipher.new
+    @key = ActiveRecord::Encryption.key_generator.generate_random_key
+  end
+
+  test "encrypts returns a encrypted test that can be decrypted with the same key" do
+    encrypted_text = @cipher.encrypt("clean text", key: @key)
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: @key)
+  end
+
+  test "by default, encrypts uses random initialization vectors for each encryption operation" do
+    assert_not_equal @cipher.encrypt("clean text", key: @key), @cipher.encrypt("clean text", key: @key)
+  end
+
+  test "deterministic encryption with :deterministic param" do
+    assert_equal @cipher.encrypt("clean text", key: @key, deterministic: true).payload, @cipher.encrypt("clean text", key: @key, deterministic: true).payload
+  end
+
+  test "raises an ArgumentError when provided a key with the wrong length" do
+    assert_raises ArgumentError do
+      @cipher.encrypt("clean text", key: "invalid key")
+    end
+  end
+
+  test "iv_length returns the iv length of the cipher" do
+    assert_equal OpenSSL::Cipher.new("aes-256-gcm").iv_len, @cipher.iv_length
+  end
+
+  test "generates different ciphertexts on different invocations with the same key (not deterministic)" do
+    key = SecureRandom.bytes(32)
+    assert_not_equal @cipher.encrypt("clean text", key: key), @cipher.encrypt("clean text", key: key)
+  end
+
+  test "decrypt can work with multiple keys" do
+    encrypted_text = @cipher.encrypt("clean text", key: @key)
+
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: [ "some wrong key", @key ])
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: [ "some wrong key", @key, "some other wrong key" ])
+    assert_equal "clean text", @cipher.decrypt(encrypted_text, key: [ @key, "some wrong key", "some other wrong key" ])
+  end
+
+  test "decrypt will raise an ActiveRecord::Encryption::Errors::Decryption error when none of the keys works" do
+    encrypted_text = @cipher.encrypt("clean text", key: @key)
+
+    assert_raises ActiveRecord::Encryption::Errors::Decryption do
+      @cipher.decrypt(encrypted_text, key: [ "some wrong key", "other wrong key" ])
+    end
+  end
+
+  test "keep encoding from the source string" do
+    encrypted_text = @cipher.encrypt("some string".dup.force_encoding(Encoding::ISO_8859_1), key: @key)
+    decrypted_text = @cipher.decrypt(encrypted_text, key: @key)
+    assert_equal Encoding::ISO_8859_1, decrypted_text.encoding
+  end
+
+  test "can encode unicode strings with emojis" do
+    encrypted_text = @cipher.encrypt("Getting around with the ⚡️Go Menu", key: @key)
+    assert_equal "Getting around with the ⚡️Go Menu", @cipher.decrypt(encrypted_text, key: @key)
+  end
+end

data/test/cases/encryption/concurrency_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/post_encrypted"
+
+class ActiveRecord::Encryption::ConcurrencyTest < ActiveRecord::EncryptionTestCase
+  setup do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+  end
+
+  test "models can be encrypted and decrypted in different threads concurrently" do
+    4.times.collect { |index| thread_encrypting_and_decrypting("thread #{index}") }.each(&:join)
+  end
+
+  def thread_encrypting_and_decrypting(thread_label)
+    EncryptedPost.insert_all! 100.times.collect { |index| { title: "Article #{index} (#{thread_label})", body: "Body #{index} (#{thread_label})" } }
+    posts = EncryptedPost.last(100)
+
+    Thread.new do
+      posts.each.with_index do |article, index|
+        assert_encrypted_attribute article, :title, "Article #{index} (#{thread_label})"
+        article.decrypt
+        assert_not_encrypted_attribute article, :title, "Article #{index} (#{thread_label})"
+      end
+    end
+  end
+end

data/test/cases/encryption/config_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::ConfigTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @config = ActiveRecord::Encryption::Config.new
+  end
+
+  test "required keys will raise a config error when accessed but not set" do
+    @config.primary_key = nil
+    assert_raises ActiveRecord::Encryption::Errors::Configuration do
+      @config.primary_key
+    end
+
+    @config.primary_key = "some key"
+    assert_nothing_raised do
+      @config.primary_key
+    end
+  end
+end

data/test/cases/encryption/configurable_test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/pirate"
+require "models/book"
+
+class ActiveRecord::Encryption::ConfigurableTest < ActiveRecord::EncryptionTestCase
+  test "can access context properties with top level getters" do
+    assert_equal ActiveRecord::Encryption.key_provider, ActiveRecord::Encryption.context.key_provider
+  end
+
+  test ".configure configures initial config properties" do
+    previous_key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new("some secret")
+
+    ActiveRecord::Encryption.configure \
+      primary_key: "the primary key",
+      deterministic_key: "the deterministic key",
+      key_derivation_salt: "the salt",
+      previous: [{ key_provider: previous_key_provider }]
+
+    config = ActiveRecord::Encryption.config
+
+    assert_equal "the primary key", config.primary_key
+    assert_equal "the deterministic key", config.deterministic_key
+    assert_equal "the salt", config.key_derivation_salt
+    assert_equal previous_key_provider, config.previous_schemes.first.key_provider
+  end
+
+  test "can add listeners that will get invoked when declaring encrypted attributes" do
+    @klass, @attribute_name = nil
+    ActiveRecord::Encryption.on_encrypted_attribute_declared do |declared_klass, declared_attribute_name|
+      @klass = declared_klass
+      @attribute_name = declared_attribute_name
+    end
+
+    klass = Class.new(Book) do
+      encrypts :isbn
+    end
+
+    assert_equal klass, @klass
+    assert_equal :isbn, @attribute_name
+  end
+
+  test "installing autofiltered parameters will add the encrypted attribute as a filter parameter using the dot notation" do
+    application = Struct.new(:config).new(Struct.new(:filter_parameters).new([]))
+
+    with_auto_filtered_parameters(application) do
+      NamedPirate = Class.new(Pirate) do
+        self.table_name = "pirates"
+      end
+      NamedPirate.encrypts :catchphrase
+    end
+
+    assert_includes application.config.filter_parameters, "named_pirate.catchphrase"
+  end
+
+  test "installing autofiltered parameters will work with unnamed classes" do
+    application = Struct.new(:config).new(Struct.new(:filter_parameters).new([]))
+
+    with_auto_filtered_parameters(application) do
+      Class.new(Pirate) do
+        self.table_name = "pirates"
+        encrypts :catchphrase
+      end
+    end
+
+    assert_includes application.config.filter_parameters, "catchphrase"
+  end
+
+  test "exclude the installation of autofiltered params" do
+    ActiveRecord::Encryption.config.excluded_from_filter_parameters = [:catchphrase]
+
+    application = Struct.new(:config).new(Struct.new(:filter_parameters).new([]))
+
+    with_auto_filtered_parameters(application) do
+      Class.new(Pirate) do
+        self.table_name = "pirates"
+        encrypts :catchphrase
+      end
+    end
+
+    assert_equal [], application.config.filter_parameters
+
+    ActiveRecord::Encryption.config.excluded_from_filter_parameters = []
+  end
+
+  private
+    def with_auto_filtered_parameters(application)
+      auto_filtered_parameters = ActiveRecord::Encryption::AutoFilteredParameters.new(application)
+      yield
+      auto_filtered_parameters.enable
+    end
+end

data/test/cases/encryption/contexts_test.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/book_encrypted"
+require "models/post_encrypted"
+
+class ActiveRecord::Encryption::ContextsTest < ActiveRecord::EncryptionTestCase
+  fixtures :posts
+
+  setup do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    @post = EncryptedPost.create!(title: "Some encrypted post title", body: "Some body")
+    @title_cleartext = @post.title
+    @title_ciphertext = @post.ciphertext_for(:title)
+  end
+
+  test ".with_encryption_context lets you override properties" do
+    ActiveRecord::Encryption.with_encryption_context(encryptor: ActiveRecord::Encryption::NullEncryptor.new) do
+      assert_equal @title_ciphertext, @post.reload.title
+
+      @post.update!(title: "Some new title")
+    end
+
+    assert_equal "Some new title", @post.title_before_type_cast
+  end
+
+  test ".with_encryption_context will restore previous context properties when there is an error" do
+    ActiveRecord::Encryption.with_encryption_context(encryptor: ActiveRecord::Encryption::NullEncryptor.new) do
+      raise "Some error"
+    end
+  rescue
+    assert_encrypted_attribute @post.reload, :title, @title_cleartext
+  end
+
+  test ".with_encryption_context can be nested multiple times" do
+    ActiveRecord::Encryption.with_encryption_context(encryptor: encryptor_1 = ActiveRecord::Encryption::NullEncryptor.new) do
+      assert_equal encryptor_1, ActiveRecord::Encryption.encryptor
+
+      ActiveRecord::Encryption.with_encryption_context(encryptor: encryptor_2 = ActiveRecord::Encryption::NullEncryptor.new) do
+        assert_equal encryptor_2, ActiveRecord::Encryption.encryptor
+
+        ActiveRecord::Encryption.with_encryption_context(encryptor: encryptor_3 = ActiveRecord::Encryption::NullEncryptor.new) do
+          assert_equal encryptor_3, ActiveRecord::Encryption.encryptor
+        end
+
+        assert_equal encryptor_2, ActiveRecord::Encryption.encryptor
+      end
+
+      assert_equal encryptor_1, ActiveRecord::Encryption.encryptor
+    end
+  end
+
+  test ".without_encryption won't decrypt or encrypt data automatically" do
+    ActiveRecord::Encryption.without_encryption do
+      assert_equal @title_ciphertext, @post.reload.title
+
+      @post.update!(title: "Some new title")
+    end
+
+    assert_not_encrypted_attribute @post, :title, "Some new title"
+  end
+
+  test ".without_encryption doesn't raise on binary encoded data" do
+    assert_nothing_raised do
+      ActiveRecord::Encryption.without_encryption do
+        EncryptedBook.create!(name: "Dune".encode(Encoding::BINARY))
+      end
+    end
+  end
+
+  test ".protecting_encrypted_data don't decrypt attributes automatically" do
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_equal @title_ciphertext, @post.reload.title
+    end
+  end
+
+  test ".protecting_encrypted_data allows db-queries on deterministic attributes" do
+    book = EncryptedBook.create! name: "Dune"
+
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_equal book, EncryptedBook.find_by(name: "Dune")
+    end
+  end
+
+  test "can't encrypt or decrypt in protected mode" do
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_raises ActiveRecord::Encryption::Errors::Configuration do
+        @post.encrypt
+      end
+
+      assert_raises ActiveRecord::Encryption::Errors::Configuration do
+        @post.decrypt
+      end
+    end
+  end
+
+  test ".protecting_encrypted_data will raise a validation error when modifying encrypting attributes" do
+    ActiveRecord::Encryption.protecting_encrypted_data do
+      assert_raises ActiveRecord::RecordInvalid do
+        @post.update!(title: "Some new title")
+      end
+    end
+  end
+end

data/test/cases/encryption/derived_secret_key_provider_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::DerivedSecretKeyProviderTest < ActiveRecord::EncryptionTestCase
+  setup do
+    @message ||= ActiveRecord::Encryption::Message.new(payload: "some secret")
+    @keys = build_keys(3)
+    @key_provider = ActiveRecord::Encryption::KeyProvider.new(@keys)
+  end
+
+  test "will derive a key with the right length from the given password" do
+    key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new("some password")
+    key = key_provider.encryption_key
+
+    assert_equal [ key ], key_provider.decryption_keys(ActiveRecord::Encryption::Message.new(payload: "some secret"))
+    assert_equal ActiveRecord::Encryption.cipher.key_length, key.secret.bytesize
+  end
+
+  test "work with multiple keys when config.store_key_references is false" do
+    ActiveRecord::Encryption.config.store_key_references = false
+
+    assert_encryptor_works_with @key_provider
+  end
+
+  test "work with multiple keys when config.store_key_references is true" do
+    ActiveRecord::Encryption.config.store_key_references = true
+
+    assert_encryptor_works_with @key_provider
+  end
+end

data/test/cases/encryption/deterministic_key_provider_test.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+
+class ActiveRecord::Encryption::DeterministicKeyProviderTest < ActiveRecord::EncryptionTestCase
+  test "will raise a configuration error when trying to configure multiple keys" do
+    assert_raise ActiveRecord::Encryption::Errors::Configuration do
+      ActiveRecord::Encryption::DeterministicKeyProvider.new([ "secret 1", "secret 2" ])
+    end
+  end
+end

data/test/cases/encryption/encryptable_record_api_test.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "cases/encryption/helper"
+require "models/author_encrypted"
+require "models/book_encrypted"
+require "models/post_encrypted"
+
+class ActiveRecord::Encryption::EncryptableRecordApiTest < ActiveRecord::EncryptionTestCase
+  fixtures :posts
+
+  setup do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+  end
+
+  test "encrypt encrypts all the encryptable attributes" do
+    title = "The Starfleet is here!"
+    body = "<p>the Starfleet is here, we are safe now!</p>"
+
+    post = ActiveRecord::Encryption.without_encryption do
+      EncryptedPost.create! title: title, body: body
+    end
+
+    post.encrypt
+
+    assert_encrypted_attribute(post, :title, title)
+    assert_encrypted_attribute(post, :body, body)
+  end
+
+  test "encrypt won't fail for classes without attributes to encrypt" do
+    assert_nothing_raised do
+      posts(:welcome).encrypt
+    end
+  end
+
+  test "decrypt decrypts encrypted attributes" do
+    title = "the Starfleet is here!"
+    body = "<p>the Starfleet is here, we are safe now!</p>"
+    post = EncryptedPost.create! title: title, body: body
+    assert_encrypted_attribute(post, :title, title)
+    assert_encrypted_attribute(post, :body, body)
+
+    post.decrypt
+
+    assert_not_encrypted_attribute post.reload, :title, title
+    assert_not_encrypted_attribute post, :body, body
+  end
+
+  test "decrypt can be invoked multiple times" do
+    post = EncryptedPost.create! title: "the Starfleet is here", body: "<p>the Starfleet is here, we are safe now!</p>"
+
+    3.times { post.decrypt }
+
+    assert_not_encrypted_attribute post.reload, :title, "the Starfleet is here"
+    assert_not_encrypted_attribute post, :body, "<p>the Starfleet is here, we are safe now!</p>"
+  end
+
+  test "encrypt can be invoked multiple times" do
+    post = EncryptedPost.create! title: "the Starfleet is here", body: "<p>the Starfleet is here, we are safe now!</p>"
+
+    3.times { post.encrypt }
+
+    assert_encrypted_attribute post.reload, :title, "the Starfleet is here"
+    assert_encrypted_attribute post, :body, "<p>the Starfleet is here, we are safe now!</p>"
+  end
+
+  test "encrypted_attribute? returns false for regular attributes" do
+    book = EncryptedBook.new(created_at: 1.day.ago)
+    assert_not book.encrypted_attribute?(:created_at)
+  end
+
+  test "encrypted_attribute? returns true for encrypted attributes which content is encrypted" do
+    book = EncryptedBook.create!(name: "Dune")
+    assert book.encrypted_attribute?(:name)
+  end
+
+  test "encrypted_attribute? returns false for encrypted attributes which content is not encrypted" do
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: "Dune") }
+    assert_not book.encrypted_attribute?(:name)
+  end
+
+  test "ciphertext_for returns the ciphertext for a given attribute" do
+    book = EncryptedBook.create!(name: "Dune")
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "ciphertext_for returns the persisted ciphertext for a non-deterministically encrypted attribute" do
+    post = EncryptedPost.create!(title: "Fear is the mind-killer", body: "Fear is the little-death...")
+
+    assert_equal post.title_before_type_cast, post.ciphertext_for(:title)
+    assert_ciphertext_decrypts_to post, :title, post.ciphertext_for(:title)
+  end
+
+  test "ciphertext_for returns the ciphertext of a new value" do
+    book = EncryptedBook.create!(name: "Dune")
+    book.name = "Arrakis"
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "ciphertext_for returns the ciphertext of a decrypted value" do
+    book = EncryptedBook.create!(name: "Dune")
+    book.decrypt
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "ciphertext_for returns the ciphertext of a value when the record is new" do
+    book = EncryptedBook.new(name: "Dune")
+
+    assert_ciphertext_decrypts_to book, :name, book.ciphertext_for(:name)
+  end
+
+  test "encrypt won't change the encoding of strings even when compression is used" do
+    title = "The Starfleet is here  #{'OMG👌' * 50}!"
+    encoding = title.encoding
+    post = ActiveRecord::Encryption.without_encryption { EncryptedPost.create!(title: title, body: "some body") }
+    post.encrypt
+    assert_equal encoding, post.reload.title.encoding
+  end
+
+  test "encrypt will honor forced encoding for deterministic attributes" do
+    ActiveRecord::Encryption.config.forced_encoding_for_deterministic_encryption = Encoding::UTF_8
+
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: "Dune".encode("US-ASCII")) }
+    book.encrypt
+    assert_equal Encoding::UTF_8, book.reload.name.encoding
+  end
+
+  test "encrypt won't force encoding for deterministic attributes when option is nil" do
+    ActiveRecord::Encryption.config.forced_encoding_for_deterministic_encryption = nil
+
+    book = ActiveRecord::Encryption.without_encryption { EncryptedBook.create!(name: "Dune".encode("US-ASCII")) }
+    book.encrypt
+    assert_equal Encoding::US_ASCII, book.reload.name.encoding
+  end
+
+  test "encrypt will preserve case when :ignore_case option is used" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    book = create_unencrypted_book_ignoring_case name: "Dune"
+
+    ActiveRecord::Encryption.without_encryption { assert_equal "Dune", book.reload.name }
+    assert_equal "Dune", book.name
+
+    book.encrypt
+
+    assert_equal "Dune", book.reload.name
+  end
+
+  test "re-encrypting will preserve case when :ignore_case option is used" do
+    ActiveRecord::Encryption.config.support_unencrypted_data = true
+
+    book = create_unencrypted_book_ignoring_case name: "Dune"
+
+    ActiveRecord::Encryption.without_encryption { assert_equal "Dune", book.reload.name }
+    assert_equal "Dune", book.name
+
+    2.times { book.encrypt }
+
+    assert_equal "Dune", book.reload.name
+  end
+
+  test "encrypt attributes encrypted with a previous encryption scheme" do
+    author = EncryptedAuthor.create!(name: "david")
+    old_type = EncryptedAuthor.type_for_attribute(:name).previous_types.first
+    value_encrypted_with_old_type = old_type.serialize("dhh")
+    ActiveRecord::Encryption.without_encryption do
+      author.update!(name: value_encrypted_with_old_type)
+    end
+
+    author.reload.encrypt
+    assert_equal "dhh", author.reload.name
+  end
+end