mongoid 3.1.5 → 8.0.2

data/spec/mongoid/fields_spec.rb

@@ -1,10 +1,9 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Fields do
-
-  before(:all) do
-    Mongoid.use_activesupport_time_zone = false
-  end
+  config_override :use_activesupport_time_zone, false
 
   describe "#\{field}_translations" do
 
@@ -18,6 +17,7 @@ describe Mongoid::Fields do
 
         before do
           product.description = "test"
+          I18n.enforce_available_locales = false
           ::I18n.locale = :de
           product.description = "The best"
         end
@@ -31,10 +31,14 @@ describe Mongoid::Fields do
         end
 
         it "returns all the translations" do
-          translations.should eq(
+          expect(translations).to eq(
             { "en" => "test", "de" => "The best" }
           )
         end
+
+        it "returns translations as a HashWithIndifferentAccess" do
+          expect(translations[:en]).to eq("test")
+        end
       end
 
       context "when translations do not exist" do
@@ -42,25 +46,33 @@ describe Mongoid::Fields do
         context "when no default is provided" do
 
           it "returns an empty hash" do
-            product.description_translations.should be_empty
+            expect(product.description_translations).to be_empty
           end
         end
 
         context "when a default is provided" do
 
           it "returns the translations with the default" do
-            product.name_translations.should eq(
+            expect(product.name_translations).to eq(
               { "en" => "no translation" }
             )
           end
         end
       end
+
+      it "should have alias method #\{field}_t" do
+        expect(product.method(:name_t)).to eq product.method(:name_translations)
+      end
     end
 
     context "when the field is not localized" do
 
       it "does not respond to the method" do
-        product.should_not respond_to(:price_translations)
+        expect(product).to_not respond_to(:price_translations)
+      end
+
+      it "does not respond to the alias method" do
+        expect(product).to_not respond_to(:price_t)
       end
     end
   end
@@ -88,28 +100,28 @@ describe Mongoid::Fields do
         end
 
         it "sets the raw values of the translations" do
-          product.description_translations.should eq(translations)
+          expect(product.description_translations).to eq(translations)
         end
 
         context "when saving the new translations" do
 
           before do
-            product.save
+            product.save!
           end
 
           it "persists the changes" do
-            product.reload.description_translations.should eq(translations)
+            expect(product.reload.description_translations).to eq(translations)
           end
 
           context "when updating the translations" do
 
             before do
               product.description_translations = { "en" => "overwritten" }
-              product.save
+              product.save!
             end
 
             it "persists the changes" do
-              product.reload.description_translations.should eq(
+              expect(product.reload.description_translations).to eq(
                 { "en" => "overwritten" }
               )
             end
@@ -128,7 +140,7 @@ describe Mongoid::Fields do
         end
 
         it "sets the mongoized values of the translations" do
-          dictionary.description_translations.should eq(
+          expect(dictionary.description_translations).to eq(
             { "en" => "1", "de" => "2" }
           )
         end
@@ -136,11 +148,11 @@ describe Mongoid::Fields do
         context "when saving the new translations" do
 
           before do
-            dictionary.save
+            dictionary.save!
           end
 
           it "persists the changes" do
-            dictionary.reload.description_translations.should eq(
+            expect(dictionary.reload.description_translations).to eq(
               { "en" => "1", "de" => "2" }
             )
           end
@@ -149,23 +161,31 @@ describe Mongoid::Fields do
 
             before do
               dictionary.description_translations = { "en" => "overwritten" }
-              dictionary.save
+              dictionary.save!
             end
 
             it "persists the changes" do
-              dictionary.reload.description_translations.should eq(
+              expect(dictionary.reload.description_translations).to eq(
                 { "en" => "overwritten" }
               )
             end
           end
         end
       end
+
+      it "should have alias method #\{field}_t=" do
+        expect(product.method(:name_t=)).to eq product.method(:name_translations=)
+      end
     end
 
     context "when the field is not localized" do
 
       it "does not respond to the method" do
-        product.should_not respond_to(:price_translations=)
+        expect(product).to_not respond_to(:price_translations=)
+      end
+
+      it "does not respond to the alias method" do
+        expect(product).to_not respond_to(:price_t=)
       end
     end
   end
@@ -179,7 +199,7 @@ describe Mongoid::Fields do
     context "when the document is subclassed" do
 
       it "does not include the child aliases" do
-        person.aliased_fields.keys.should_not include("spec")
+        expect(person.aliased_fields.keys).to_not include("spec")
       end
     end
   end
@@ -193,19 +213,19 @@ describe Mongoid::Fields do
       end
 
       it "includes the _id field" do
-        shape.attribute_names.should include("_id")
+        expect(shape.attribute_names).to include("_id")
       end
 
       it "includes the _type field" do
-        shape.attribute_names.should include("_type")
+        expect(shape.attribute_names).to include("_type")
       end
 
       it "includes its own fields" do
-        shape.attribute_names.should include("x")
+        expect(shape.attribute_names).to include("x")
       end
 
       it "does not return subclass fields" do
-        shape.attribute_names.should_not include("radius")
+        expect(shape.attribute_names).to_not include("radius")
       end
     end
 
@@ -216,23 +236,23 @@ describe Mongoid::Fields do
       end
 
       it "includes the _id field" do
-        circle.attribute_names.should include("_id")
+        expect(circle.attribute_names).to include("_id")
       end
 
       it "includes the _type field" do
-        circle.attribute_names.should include("_type")
+        expect(circle.attribute_names).to include("_type")
       end
 
       it "includes the first parent field" do
-        circle.attribute_names.should include("x")
+        expect(circle.attribute_names).to include("x")
       end
 
       it "includes the second parent field" do
-        circle.attribute_names.should include("y")
+        expect(circle.attribute_names).to include("y")
       end
 
       it "includes the child fields" do
-        circle.attribute_names.should include("radius")
+        expect(circle.attribute_names).to include("radius")
       end
     end
   end
@@ -242,42 +262,42 @@ describe Mongoid::Fields do
     context "when the class is a parent" do
 
       it "includes the _id field" do
-        Shape.attribute_names.should include("_id")
+        expect(Shape.attribute_names).to include("_id")
       end
 
       it "includes the _type field" do
-        Shape.attribute_names.should include("_type")
+        expect(Shape.attribute_names).to include("_type")
       end
 
       it "includes its own fields" do
-        Shape.attribute_names.should include("x")
+        expect(Shape.attribute_names).to include("x")
       end
 
       it "does not return subclass fields" do
-        Shape.attribute_names.should_not include("radius")
+        expect(Shape.attribute_names).to_not include("radius")
       end
     end
 
     context "when the class is a subclass" do
 
       it "includes the _id field" do
-        Circle.attribute_names.should include("_id")
+        expect(Circle.attribute_names).to include("_id")
       end
 
       it "includes the _type field" do
-        Circle.attribute_names.should include("_type")
+        expect(Circle.attribute_names).to include("_type")
       end
 
       it "includes the first parent field" do
-        Circle.attribute_names.should include("x")
+        expect(Circle.attribute_names).to include("x")
       end
 
       it "includes the second parent field" do
-        Circle.attribute_names.should include("y")
+        expect(Circle.attribute_names).to include("y")
       end
 
       it "includes the child fields" do
-        Circle.attribute_names.should include("radius")
+        expect(Circle.attribute_names).to include("radius")
       end
     end
   end
@@ -289,12 +309,114 @@ describe Mongoid::Fields do
       end
     end
 
+    context "when providing a root Boolean type" do
+
+      let(:klass) do
+        Class.new do
+          include Mongoid::Document
+        end
+      end
+
+      it "converts to Mongoid::Boolean" do
+        expect(klass.field(:test, type: Mongoid::Boolean).type).to be(Mongoid::Boolean)
+      end
+    end
+
+    context "when using symbol types" do
+
+      let(:klass) do
+        Class.new do
+          include Mongoid::Document
+        end
+      end
+
+      it "converts :array to Array" do
+        expect(klass.field(:test, type: :array).type).to be(Array)
+      end
+
+      it "converts :big_decimal to BigDecimal" do
+        expect(klass.field(:test, type: :big_decimal).type).to be(BigDecimal)
+      end
+
+      it "converts :binary to BSON::Binary" do
+        expect(klass.field(:test, type: :binary).type).to be(BSON::Binary)
+      end
+
+      it "converts :boolean to Mongoid::Boolean" do
+        expect(klass.field(:test, type: :boolean).type).to be(Mongoid::Boolean)
+      end
+
+      it "converts :date to Date" do
+        expect(klass.field(:test, type: :date).type).to be(Date)
+      end
+
+      it "converts :date_time to DateTime" do
+        expect(klass.field(:test, type: :date_time).type).to be(DateTime)
+      end
+
+      it "converts :float to Float" do
+        expect(klass.field(:test, type: :float).type).to be(Float)
+      end
+
+      it "converts :hash to Hash" do
+        expect(klass.field(:test, type: :hash).type).to be(Hash)
+      end
+
+      it "converts :integer to Integer" do
+        expect(klass.field(:test, type: :integer).type).to be(Integer)
+      end
+
+      it "converts :object_id to BSON::ObjectId" do
+        expect(klass.field(:test, type: :object_id).type).to be(BSON::ObjectId)
+      end
+
+      it "converts :range to Range" do
+        expect(klass.field(:test, type: :range).type).to be(Range)
+      end
+
+      it "converts :regexp to Rexegp" do
+        expect(klass.field(:test, type: :regexp).type).to be(Regexp)
+      end
+
+      it "converts :set to Set" do
+        expect(klass.field(:test, type: :set).type).to be(Set)
+      end
+
+      it "converts :string to String" do
+        expect(klass.field(:test, type: :string).type).to be(String)
+      end
+
+      it "converts :symbol to Symbol" do
+        expect(klass.field(:test, type: :symbol).type).to be(Symbol)
+      end
+
+      it "converts :time to Time" do
+        expect(klass.field(:test, type: :time).type).to be(Time)
+      end
+
+      context 'when using an unknown symbol' do
+        it 'raises InvalidFieldType' do
+          lambda do
+            klass.field(:test, type:  :bogus)
+          end.should raise_error(Mongoid::Errors::InvalidFieldType, /defines a field 'test' with an unknown type value :bogus/)
+        end
+      end
+
+      context 'when using an unknown string' do
+        it 'raises InvalidFieldType' do
+          lambda do
+            klass.field(:test, type:  'bogus')
+          end.should raise_error(Mongoid::Errors::InvalidFieldType, /defines a field 'test' with an unknown type value "bogus"/)
+        end
+      end
+    end
+
     context "when the options are valid" do
 
       context "when the options are all standard" do
 
         before do
-          Band.field :acceptable, type: Boolean
+          Band.field :acceptable, type: Mongoid::Boolean
         end
 
         after do
@@ -302,18 +424,56 @@ describe Mongoid::Fields do
         end
 
         it "adds the field to the model" do
-          Band.fields["acceptable"].should_not be_nil
+          expect(Band.fields["acceptable"]).to_not be_nil
         end
       end
 
       context "when a custom option is provided" do
 
         before do
-          Band.field :acceptable, type: Boolean, custom: true
+          Band.field :acceptable, type: Mongoid::Boolean, custom: true
         end
 
         it "adds the field to the model" do
-          Band.fields["acceptable"].should_not be_nil
+          expect(Band.fields["acceptable"]).to_not be_nil
+        end
+      end
+    end
+
+    context "when the Symbol type is used" do
+
+      before do
+        Mongoid::Warnings.class_eval do
+          @symbol_type_deprecated = false
+        end
+      end
+
+      after do
+        Label.fields.delete("should_warn")
+      end
+
+      it "warns that the BSON symbol type is deprecated" do
+        expect(Mongoid.logger).to receive(:warn)
+
+        Label.field :should_warn, type: Symbol
+      end
+
+      it "warns on first use of Symbol type only" do
+        expect(Mongoid.logger).to receive(:warn).once
+
+        Label.field :should_warn, type: Symbol
+      end
+
+      context 'when using Symbol field type in multiple classes' do
+        after do
+          Truck.fields.delete("should_warn")
+        end
+
+        it "warns on first use of Symbol type only" do
+          expect(Mongoid.logger).to receive(:warn).once
+
+          Label.field :should_warn, type: Symbol
+          Truck.field :should_warn, type: Symbol
         end
       end
     end
@@ -322,7 +482,7 @@ describe Mongoid::Fields do
 
       it "raises an error" do
         expect {
-          Band.field :unacceptable, bad: true
+          Label.field :unacceptable, bad: true
         }.to raise_error(Mongoid::Errors::InvalidFieldOption)
       end
     end
@@ -333,7 +493,7 @@ describe Mongoid::Fields do
     context "when the field is binary" do
 
       let(:binary) do
-        Moped::BSON::Binary.new(:md5, "testing")
+        BSON::Binary.new("testing", :md5)
       end
 
       let(:registry) do
@@ -341,7 +501,7 @@ describe Mongoid::Fields do
       end
 
       it "returns the binary data intact" do
-        registry.data.should eq(binary)
+        expect(registry.data).to eq(binary)
       end
     end
 
@@ -362,7 +522,7 @@ describe Mongoid::Fields do
         end
 
         it "returns the default locale value" do
-          description.should eq("The best")
+          expect(description).to eq("The best")
         end
       end
 
@@ -382,7 +542,7 @@ describe Mongoid::Fields do
         end
 
         it "returns the set locale value" do
-          description.should eq("The best")
+          expect(description).to eq("The best")
         end
       end
 
@@ -403,7 +563,7 @@ describe Mongoid::Fields do
         end
 
         it "returns the current locale value" do
-          description.should eq("Cheaper drinks")
+          expect(description).to eq("Cheaper drinks")
         end
       end
     end
@@ -417,15 +577,151 @@ describe Mongoid::Fields do
     context "when the attribute has not been assigned" do
 
       it "delgates to the getter" do
-        person.age_before_type_cast.should eq(person.age)
+        expect(person.age_before_type_cast).to eq(person.age)
       end
     end
 
     context "when the attribute has been assigned" do
 
       it "returns the attribute before type cast" do
-        person.age = "old"
-        person.age_before_type_cast.should eq("old")
+        person.age = "42"
+        expect(person.age_before_type_cast).to eq("42")
+      end
+    end
+
+    context "when reloading" do
+
+      let(:product) do
+        Product.create!(price: '1')
+      end
+
+      before do
+        product.reload
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(product.attributes_before_type_cast).to eq(product.attributes)
+      end
+
+      it "the *_before_type_cast method returns the demongoized value" do
+        expect(product.price_before_type_cast).to eq(1)
+      end
+    end
+
+    context "when reloading and writing a demongoizable value" do
+
+      let(:product) do
+        Product.create!.tap do |product|
+          Product.collection.update_one({ _id: product.id }, { :$set => { price: '1' }})
+        end
+      end
+
+      before do
+        product.reload
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(product.attributes_before_type_cast).to eq(product.attributes)
+      end
+
+      it "the *_before_type_cast method returns the mongoized value" do
+        expect(product.price_before_type_cast).to eq('1')
+      end
+    end
+
+    context "when reading from the db" do
+
+      let(:product) do
+        Product.create!(price: '1')
+      end
+
+      let(:from_db) do
+        Product.find(product.id)
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(from_db.attributes_before_type_cast).to eq(from_db.attributes)
+      end
+
+      it "the *_before_type_cast method returns the demongoized value" do
+        expect(from_db.price_before_type_cast).to eq(1)
+      end
+    end
+
+    context "when reading from the db after writing a demongoizable value" do
+
+      let(:product) do
+        Product.create!.tap do |product|
+          Product.collection.update_one({ _id: product.id }, { :$set => { price: '1' }})
+        end
+      end
+
+      let(:from_db) do
+        Product.find(product.id)
+      end
+
+      it "resets the attributes_before_type_cast to the attributes hash" do
+        expect(from_db.attributes_before_type_cast).to eq(from_db.attributes)
+      end
+
+      it "the *_before_type_cast method returns the mongoized value" do
+        expect(from_db.price_before_type_cast).to eq('1')
+      end
+    end
+
+    context "when making a new model" do
+
+      context "when using new with no options" do
+        let(:product) { Product.new }
+
+        it "sets the attributes_before_type_cast to the attributes hash" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
+      end
+
+      context "when using new with options" do
+        let(:product) { Product.new(price: '1') }
+
+        let(:abtc) do
+          product.attributes.merge('price' => '1')
+        end
+
+        it "has the attributes before type cast" do
+          expect(product.attributes_before_type_cast).to eq(abtc)
+        end
+      end
+
+      context "when persisting the model" do
+        let(:product) { Product.new(price: '1') }
+
+        let(:abtc) do
+          product.attributes.merge('price' => '1')
+        end
+
+        before do
+          expect(product.attributes_before_type_cast).to eq(abtc)
+          product.save!
+        end
+
+        it "resets the attributes_before_type_cast to the attributes" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
+      end
+
+      context "when using create! without options" do
+        let(:product) { Product.create! }
+
+        it "resets the attributes_before_type_cast to the attributes" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
+      end
+
+      context "when using create! with options" do
+        let(:product) { Product.create!(price: '1') }
+
+        it "resets the attributes_before_type_cast to the attributes" do
+          expect(product.attributes_before_type_cast).to eq(product.attributes)
+        end
       end
     end
   end
@@ -436,10 +732,24 @@ describe Mongoid::Fields do
       Product.new
     end
 
+    context "when setting via the setter" do
+
+      it "returns the set value" do
+        expect(product.price = 10).to eq(10)
+      end
+    end
+
+    context "when setting via send" do
+
+      it "returns the set value" do
+        expect(product.send(:price=, 10)).to eq(10)
+      end
+    end
+
     context "when the field is binary" do
 
       let(:binary) do
-        Moped::BSON::Binary.new(:md5, "testing")
+        BSON::Binary.new("testing", :md5)
       end
 
       let(:registry) do
@@ -451,7 +761,7 @@ describe Mongoid::Fields do
       end
 
       it "returns the binary data intact" do
-        registry.data.should eq(binary)
+        expect(registry.data).to eq(binary)
       end
     end
 
@@ -459,18 +769,18 @@ describe Mongoid::Fields do
 
       before do
         product.stores = [ "kadewe", "karstadt" ]
-        product.save
+        product.save!
       end
 
       context "when setting the value to nil" do
 
         before do
           product.stores = nil
-          product.save
+          product.save!
         end
 
         it "allows the set" do
-          product.stores.should be_nil
+          expect(product.stores).to be_nil
         end
       end
 
@@ -478,15 +788,15 @@ describe Mongoid::Fields do
 
         before do
           product.stores = [ "kadewe", nil ]
-          product.save
+          product.save!
         end
 
         it "allows the set of nil values" do
-          product.stores.should eq([ "kadewe", nil ])
+          expect(product.stores).to eq([ "kadewe", nil ])
         end
 
         it "persists the nil values" do
-          product.reload.stores.should eq([ "kadewe", nil ])
+          expect(product.reload.stores).to eq([ "kadewe", nil ])
         end
       end
 
@@ -494,15 +804,15 @@ describe Mongoid::Fields do
 
         before do
           product.stores = [ "karstadt", "kadewe" ]
-          product.save
+          product.save!
         end
 
         it "reverses the values" do
-          product.stores.should eq([ "karstadt", "kadewe" ])
+          expect(product.stores).to eq([ "karstadt", "kadewe" ])
         end
 
         it "persists the changes" do
-          product.reload.stores.should eq([ "karstadt", "kadewe" ])
+          expect(product.reload.stores).to eq([ "karstadt", "kadewe" ])
         end
       end
     end
@@ -520,7 +830,7 @@ describe Mongoid::Fields do
         end
 
         it "sets the value in the default locale" do
-          description.should eq({ "en" => "Cheap drinks" })
+          expect(description).to eq({ "en" => "Cheap drinks" })
         end
       end
 
@@ -540,7 +850,7 @@ describe Mongoid::Fields do
         end
 
         it "sets the value in the default locale" do
-          description.should eq({ "de" => "Cheaper drinks" })
+          expect(description).to eq({ "de" => "Cheaper drinks" })
         end
       end
 
@@ -561,12 +871,28 @@ describe Mongoid::Fields do
         end
 
         it "sets the value in both locales" do
-          description.should eq(
+          expect(description).to eq(
             { "de" => "Cheaper drinks", "en" => "Cheap drinks" }
           )
         end
       end
     end
+
+    context "when the field needs to be mongoized" do
+
+      before do
+        product.price = "1"
+        product.save!
+      end
+
+      it "mongoizes the value" do
+        expect(product.price).to eq(1)
+      end
+
+      it "stores the value in the mongoized form" do
+        expect(product.attributes_before_type_cast["price"]).to eq(1)
+      end
+    end
   end
 
   describe "#defaults" do
@@ -584,7 +910,7 @@ describe Mongoid::Fields do
       context "when provided a default array" do
 
         before do
-          Person.field(:array_testing, type: Array, default: [])
+          Person.field(:array_testing, type: Array, default: [], overwrite: true)
         end
 
         after do
@@ -593,7 +919,7 @@ describe Mongoid::Fields do
         end
 
         it "returns an equal object of a different instance" do
-          person_one.array_testing.object_id.should_not eq(
+          expect(person_one.array_testing.object_id).to_not eq(
             person_two.array_testing.object_id
           )
         end
@@ -602,7 +928,7 @@ describe Mongoid::Fields do
       context "when provided a default hash" do
 
         before do
-          Person.field(:hash_testing, type: Hash, default: {})
+          Person.field(:hash_testing, type: Hash, default: {}, overwrite: true)
         end
 
         after do
@@ -610,7 +936,7 @@ describe Mongoid::Fields do
         end
 
         it "returns an equal object of a different instance" do
-          person_one.hash_testing.object_id.should_not eq(
+          expect(person_one.hash_testing.object_id).to_not eq(
             person_two.hash_testing.object_id
           )
         end
@@ -624,7 +950,8 @@ describe Mongoid::Fields do
             Person.field(
               :generated_testing,
               type: Float,
-              default: ->{ Time.now.to_f }
+              default: ->{ Time.now.to_f },
+              overwrite: true
             )
           end
 
@@ -634,7 +961,7 @@ describe Mongoid::Fields do
           end
 
           it "returns an equal object of a different instance" do
-            person_one.generated_testing.object_id.should_not eq(
+            expect(person_one.generated_testing.object_id).to_not eq(
               person_two.generated_testing.object_id
             )
           end
@@ -646,7 +973,8 @@ describe Mongoid::Fields do
             Person.field(
               :rank,
               type: Integer,
-              default: ->{ title? ? 1 : 2 }
+              default: ->{ title? ? 1 : 2 },
+              overwrite: true
             )
           end
 
@@ -656,7 +984,7 @@ describe Mongoid::Fields do
           end
 
           it "yields the document to the proc" do
-            Person.new.rank.should eq(2)
+            expect(Person.new.rank).to eq(2)
           end
         end
       end
@@ -669,7 +997,8 @@ describe Mongoid::Fields do
       end
 
       it "does not return subclass defaults" do
-        shape.pre_processed_defaults.should eq([ "_id", "x", "y", "_type" ])
+        expect(shape.pre_processed_defaults).to eq([ "_id", "x", "y" ])
+        expect(shape.post_processed_defaults).to eq([ "_type" ])
       end
     end
 
@@ -680,7 +1009,8 @@ describe Mongoid::Fields do
       end
 
       it "has the parent and child defaults" do
-        circle.pre_processed_defaults.should eq([ "_id", "x", "y", "_type", "radius" ])
+        expect(circle.pre_processed_defaults).to eq([ "_id", "x", "y", "radius" ])
+        expect(circle.post_processed_defaults).to eq([ "_type" ])
       end
     end
   end
@@ -688,19 +1018,42 @@ describe Mongoid::Fields do
   describe ".field" do
 
     it "returns the generated field" do
-      Person.field(:testing).should equal Person.fields["testing"]
+      expect(Person.field(:testing)).to eq(Person.fields["testing"])
     end
 
     context "when the field name conflicts with mongoid's internals" do
 
-      context "when the field is named metadata" do
+      [:_association, :invalid].each do |meth|
+        context "when the field is named #{meth}" do
+
+          it "raises an error" do
+            expect {
+              Person.field(meth)
+            }.to raise_error(Mongoid::Errors::InvalidField, /Defining a field named '#{meth}' is not allowed/)
+          end
+        end
+      end
+    end
+
+    context "when field already exist and validate_duplicate is enable" do
+      context 'when exception is enabled' do
+        config_override :duplicate_fields_exception, true
 
         it "raises an error" do
           expect {
-            Person.field(:metadata)
+            Person.field(:title)
           }.to raise_error(Mongoid::Errors::InvalidField)
         end
       end
+
+      context 'when exception is disabled' do
+        config_override :duplicate_fields_exception, false
+        it "doesn't raise an error" do
+          expect {
+            Class.new(Person)
+          }.to_not raise_error
+        end
+      end
     end
 
     context "when the field is a time" do
@@ -724,7 +1077,7 @@ describe Mongoid::Fields do
         end
 
         it "performs the necessary time conversions" do
-          person.lunch_time.to_s.should eq(time.getlocal.to_s)
+          expect(person.lunch_time.to_s).to eq(time.getlocal.to_s)
         end
       end
     end
@@ -732,7 +1085,7 @@ describe Mongoid::Fields do
     context "when providing no options" do
 
       before do
-        Person.field(:testing)
+        Person.field(:testing, overwrite: true)
       end
 
       let(:person) do
@@ -740,15 +1093,15 @@ describe Mongoid::Fields do
       end
 
       it "adds a reader for the fields defined" do
-        person.testing.should eq("Test")
+        expect(person.testing).to eq("Test")
       end
 
       it "adds a writer for the fields defined" do
-        (person.testing = "Testy").should eq("Testy")
+        (person.testing = expect("Testy")).to eq("Testy")
       end
 
-      it "adds an existance method" do
-        Person.new.testing?.should be_false
+      it "adds an existence method" do
+        expect(Person.new.testing?).to be false
       end
 
       context "when overwriting an existing field" do
@@ -765,7 +1118,7 @@ describe Mongoid::Fields do
         end
 
         it "properly overwrites the method" do
-          person.testing_override_called.should be_true
+          expect(person.testing_override_called).to be true
         end
       end
     end
@@ -777,7 +1130,7 @@ describe Mongoid::Fields do
       end
 
       it "returns the given value" do
-        bob.reading.should eq(10.023)
+        expect(bob.reading).to eq(10.023)
       end
     end
 
@@ -788,7 +1141,7 @@ describe Mongoid::Fields do
       end
 
       it "adds an accessor method with a question mark" do
-        person.terms?.should be_true
+        expect(person.terms?).to be true
       end
     end
 
@@ -799,39 +1152,39 @@ describe Mongoid::Fields do
       end
 
       before do
-        Person.field :aliased, as: :alias, type: Boolean
+        Person.field :aliased, as: :alias, type: Mongoid::Boolean, overwrite: true
       end
 
       it "uses the alias to write the attribute" do
-        (person.alias = true).should be_true
+        expect(person.alias = true).to be true
       end
 
       it "uses the alias to read the attribute" do
-        person.alias.should be_true
+        expect(person.alias).to be true
       end
 
       it "uses the alias for the query method" do
-        person.should be_alias
+        expect(person).to be_alias
       end
 
       it "uses the name to write the attribute" do
-        (person.aliased = true).should be_true
+        expect(person.aliased = true).to be true
       end
 
       it "uses the name to read the attribute" do
-        person.aliased.should be_true
+        expect(person.aliased).to be true
       end
 
       it "uses the name for the query method" do
-        person.should be_aliased
+        expect(person).to be_aliased
       end
 
       it "creates dirty methods for the name" do
-        person.should respond_to(:aliased_changed?)
+        expect(person).to respond_to(:aliased_changed?)
       end
 
       it "creates dirty methods for the alias" do
-        person.should respond_to(:alias_changed?)
+        expect(person).to respond_to(:alias_changed?)
       end
 
       context "when changing the name" do
@@ -841,11 +1194,11 @@ describe Mongoid::Fields do
         end
 
         it "sets name_changed?" do
-          person.aliased_changed?.should be_true
+          expect(person.aliased_changed?).to be true
         end
 
         it "sets alias_changed?" do
-          person.alias_changed?.should be_true
+          expect(person.alias_changed?).to be true
         end
       end
 
@@ -856,11 +1209,11 @@ describe Mongoid::Fields do
         end
 
         it "sets name_changed?" do
-          person.aliased_changed?.should be_true
+          expect(person.aliased_changed?).to be true
         end
 
         it "sets alias_changed?" do
-          person.alias_changed?.should be_true
+          expect(person.alias_changed?).to be true
         end
       end
 
@@ -871,7 +1224,7 @@ describe Mongoid::Fields do
         end
 
         it "properly serializes the aliased field" do
-          criteria.selector.should eq({ "aliased" => true })
+          expect(criteria.selector).to eq({ "aliased" => true })
         end
       end
     end
@@ -889,44 +1242,24 @@ describe Mongoid::Fields do
       context "when option is provided" do
 
         it "calls the handler with the model" do
-          handler.should_receive(:call).with do |model,_,_|
-            model.should eql User
-          end
-
-          User.field :custom, option: true
-        end
-
-        it "calls the handler with the field" do
-          handler.should_receive(:call).with do |_,field,_|
-            field.should eql User.fields["custom"]
-          end
-
-          User.field :custom, option: true
-        end
-
-        it "calls the handler with the option value" do
-          handler.should_receive(:call).with do |_,_,value|
-            value.should eql true
-          end
-
-          User.field :custom, option: true
+          User.field :custom, option: true, overwrite: true
+          expect(User.fields["custom"].options[:option]).to be_truthy
         end
       end
 
       context "when option is nil" do
 
         it "calls the handler" do
-          handler.should_receive(:call)
-          User.field :custom, option: nil
+          expect(handler).to receive(:call)
+          User.field :custom, option: nil, overwrite: true
         end
       end
 
       context "when option is not provided" do
 
         it "does not call the handler" do
-          handler.should_receive(:call).never
-
-          User.field :custom
+          expect(handler).to receive(:call).never
+          User.field :custom, overwrite: true
         end
       end
     end
@@ -941,11 +1274,15 @@ describe Mongoid::Fields do
       end
 
       it "includes its own fields" do
-        shape.fields.keys.should include("x")
+        expect(shape.fields.keys).to include("x")
       end
 
       it "does not return subclass fields" do
-        shape.fields.keys.should_not include("radius")
+        expect(shape.fields.keys).to_not include("radius")
+      end
+
+      it 'includes _type field' do
+        expect(shape.fields.keys).to include("_type")
       end
     end
 
@@ -956,15 +1293,37 @@ describe Mongoid::Fields do
       end
 
       it "includes the first parent field" do
-        circle.fields.keys.should include("x")
+        expect(circle.fields.keys).to include("x")
       end
 
       it "includes the second parent field" do
-        circle.fields.keys.should include("y")
+        expect(circle.fields.keys).to include("y")
       end
 
       it "includes the child fields" do
-        circle.fields.keys.should include("radius")
+        expect(circle.fields.keys).to include("radius")
+      end
+
+      it 'includes _type field' do
+        expect(circle.fields.keys).to include("_type")
+      end
+    end
+
+    context "on new subclasses" do
+      it "all subclasses get the discriminator key" do
+        class DiscriminatorParent
+          include Mongoid::Document
+        end
+
+        class DiscriminatorChild1 < DiscriminatorParent
+        end
+
+        class DiscriminatorChild2 < DiscriminatorParent
+        end
+
+        expect(DiscriminatorParent.fields.keys).to include("_type")
+        expect(DiscriminatorChild1.fields.keys).to include("_type")
+        expect(DiscriminatorChild2.fields.keys).to include("_type")
       end
     end
   end
@@ -972,7 +1331,7 @@ describe Mongoid::Fields do
   describe ".replace_field" do
 
     let!(:original) do
-      Person.field(:id_test, type: Moped::BSON::ObjectId, label: "id")
+      Person.field(:id_test, type: BSON::ObjectId, label: "id")
     end
 
     let!(:altered) do
@@ -988,11 +1347,11 @@ describe Mongoid::Fields do
     end
 
     it "sets the new type on the field" do
-      new_field.type.should eq(String)
+      expect(new_field.type).to eq(String)
     end
 
     it "keeps the options from the old field" do
-      new_field.options[:label].should eq("id")
+      expect(new_field.options[:label]).to eq("id")
     end
   end
 
@@ -1009,7 +1368,7 @@ describe Mongoid::Fields do
       end
 
       it "resets the fields" do
-        fields.keys.should include("user_id")
+        expect(fields.keys).to include("user_id")
       end
     end
 
@@ -1020,7 +1379,7 @@ describe Mongoid::Fields do
       end
 
       it "resets the fields" do
-        fields.keys.should include("user_id")
+        expect(fields.keys).to include("user_id")
       end
     end
   end
@@ -1032,158 +1391,153 @@ describe Mongoid::Fields do
     end
 
     it "sets the default value pre process" do
-      person.map_with_default.should eq({ "key" => "testing" })
+      expect(person.map_with_default).to eq({ "key" => "testing" })
     end
   end
 
-  context "when dealing with auto protection" do
+  context "when a field is defined as a big decimal" do
 
-    context "when auto protect ids and types is true" do
+    context 'when Mongoid.map_big_decimal_to_decimal128 is false' do
+      config_override :map_big_decimal_to_decimal128, false
 
-      context "when redefining as accessible" do
+      let(:band) do
+        Band.new(name: "Tool")
+      end
 
-        before do
-          Person.attr_accessible :id, :_id, :_type
-        end
+      let(:decimal) do
+        BigDecimal("1000000.00")
+      end
 
-        after do
-          Person.attr_protected :id, :_id, :_type
-        end
+      context "when setting to a big decimal" do
 
-        let(:bson_id) do
-          Moped::BSON::ObjectId.new
+        before do
+          band.sales = decimal
         end
 
-        it "allows mass assignment of id" do
-          Person.new(_id: bson_id).id.should eq(bson_id)
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq(decimal.to_s)
         end
 
-        it "allows mass assignment of type" do
-          Person.new(_type: "Something")._type.should eq("Something")
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
         end
       end
 
-      context "when redefining as protected" do
+      context "when setting to a string" do
 
         before do
-          Person.attr_protected :id, :_id, :_type
-        end
-
-        let(:bson_id) do
-          Moped::BSON::ObjectId.new
+          band.sales = decimal.to_s
         end
 
-        it "protects assignment of id" do
-          Person.new(_id: bson_id).id.should_not eq(bson_id)
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq(decimal.to_s)
         end
 
-        it "protects assignment of type" do
-          Person.new(_type: "Something")._type.should_not eq("Something")
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
         end
       end
-    end
 
-    context "when auto protecting ids and types is false" do
+      context "when setting to an integer" do
 
-      before do
-        Mongoid.protect_sensitive_fields = false
-      end
+        before do
+          band.sales = decimal.to_i
+        end
 
-      after do
-        Mongoid.protect_sensitive_fields = true
-      end
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq("1000000")
+        end
 
-      let(:klass) do
-        Class.new do
-          include Mongoid::Document
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
         end
       end
 
-      let(:bson_id) do
-        Moped::BSON::ObjectId.new
-      end
+      context "when setting to a float" do
 
-      let(:model) do
-        klass.new(id: bson_id, _type: "Model")
-      end
+        before do
+          band.sales = decimal.to_f
+        end
 
-      it "allows mass assignment of id" do
-        model.id.should eq(bson_id)
-      end
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq(decimal.to_s)
+        end
 
-      it "allows mass assignment of type" do
-        model._type.should eq("Model")
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
+        end
       end
     end
-  end
 
-  context "when a field is defined as a big decimal" do
+    context 'when Mongoid.map_big_decimal_to_decimal128 is true' do
+      config_override :map_big_decimal_to_decimal128, true
 
-    let(:band) do
-      Band.new(name: "Tool")
-    end
+      let(:band) do
+        Band.new(name: "Tool")
+      end
 
-    let(:decimal) do
-      BigDecimal.new("1000000.00")
-    end
+      let(:decimal) do
+        BigDecimal("1000000.00")
+      end
 
-    context "when setting to a big decimal" do
+      context "when setting to a big decimal" do
 
-      before do
-        band.sales = decimal
-      end
+        before do
+          band.sales = decimal
+        end
 
-      it "properly persists as a string" do
-        band.attributes["sales"].should eq(decimal.to_s)
-      end
+        it "properly persists as a BSON::Decimal128" do
+          expect(band.attributes["sales"]).to eq(BSON::Decimal128.new(decimal))
+        end
 
-      it "returns the proper big decimal" do
-        band.sales.should eq(decimal)
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
+        end
       end
-    end
 
-    context "when setting to a string" do
+      context "when setting to a string" do
 
-      before do
-        band.sales = decimal.to_s
-      end
+        before do
+          band.sales = decimal.to_s
+        end
 
-      it "properly persists as a string" do
-        band.attributes["sales"].should eq(decimal.to_s)
-      end
+        it "persists as a BSON::Decimal128" do
+          expect(band.attributes["sales"]).to eq(BSON::Decimal128.new(decimal.to_s))
+        end
 
-      it "returns the proper big decimal" do
-        band.sales.should eq(decimal)
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
+        end
       end
-    end
 
-    context "when setting to an integer" do
+      context "when setting to an integer" do
 
-      before do
-        band.sales = decimal.to_i
-      end
+        before do
+          band.sales = decimal.to_i
+        end
 
-      it "properly persists as a string" do
-        band.attributes["sales"].should eq("1000000")
-      end
+        it "persists as a BSON::Decimal128" do
+          expect(band.attributes["sales"]).to eq(BSON::Decimal128.new(decimal.to_i.to_s))
+        end
 
-      it "returns the proper big decimal" do
-        band.sales.should eq(decimal)
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
+        end
       end
-    end
 
-    context "when setting to a float" do
+      context "when setting to a float" do
 
-      before do
-        band.sales = decimal.to_f
-      end
+        before do
+          band.sales = decimal.to_f
+        end
 
-      it "properly persists as a string" do
-        band.attributes["sales"].should eq(decimal.to_s)
-      end
+        it "properly persists as a BSON::Decimal128" do
+          expect(band.attributes["sales"]).to eq(BSON::Decimal128.new(decimal.to_f.to_s))
+        end
 
-      it "returns the proper big decimal" do
-        band.sales.should eq(decimal)
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
+        end
       end
     end
   end
@@ -1191,7 +1545,7 @@ describe Mongoid::Fields do
   context "when the field is a hash of arrays" do
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     let(:map) do
@@ -1205,11 +1559,11 @@ describe Mongoid::Fields do
     before do
       person.map = map
       person.map["stack1"].reverse!
-      person.save
+      person.save!
     end
 
     it "properly updates the hash" do
-      person.map.should eq(
+      expect(person.map).to eq(
         {
           "stack1" => [ 4, 3, 2, 1 ],
           "stack2" => [ 1, 2, 3, 4 ],
@@ -1219,7 +1573,7 @@ describe Mongoid::Fields do
     end
 
     it "persists the changes" do
-      person.reload.map.should eq(
+      expect(person.reload.map).to eq(
         {
           "stack1" => [ 4, 3, 2, 1 ],
           "stack2" => [ 1, 2, 3, 4 ],
@@ -1242,11 +1596,371 @@ describe Mongoid::Fields do
       end
 
       it "does not override the parent" do
-        canvas.foo.should eq("original")
+        expect(canvas.foo).to eq("original")
       end
 
       it "overrides the default" do
-        test.foo.should eq("overridden")
+        expect(test.foo).to eq("overridden")
+      end
+    end
+  end
+
+  context "when a localized field is a boolean" do
+
+    context "when the default is true" do
+
+      let(:definition) do
+        Definition.new
+      end
+
+      it "returns the proper predicate result" do
+        expect(definition).to be_active
+      end
+    end
+  end
+
+  describe '_type field' do
+    context 'on parent class' do
+      let(:shape) { Shape.new }
+
+      it 'is correctly set' do
+        shape.attributes['_type'].should == 'Shape'
+      end
+    end
+
+    context 'on child class' do
+      let(:circle) { Circle.new }
+
+      it 'is correctly set' do
+        circle.attributes['_type'].should == 'Circle'
+      end
+    end
+  end
+
+  describe '.database_field_name' do
+
+    shared_examples_for 'database_field_name' do
+      subject { Person.database_field_name(key) }
+
+      context 'non-aliased field name' do
+        let(:key) { 't' }
+        it { is_expected.to eq 't' }
+      end
+
+      context 'aliased field name' do
+        let(:key) { 'test' }
+        it { is_expected.to eq 't' }
+      end
+
+      context 'non-aliased embeds one relation' do
+        let(:key) { 'pass' }
+        it { is_expected.to eq 'pass' }
+      end
+
+      context 'aliased embeds one relation' do
+        let(:key) { 'passport' }
+        it { is_expected.to eq 'pass' }
+      end
+
+      context 'non-aliased embeds many relation' do
+        let(:key) { 'mobile_phones' }
+        it { is_expected.to eq 'mobile_phones' }
+      end
+
+      context 'aliased embeds many relation' do
+        let(:key) { 'phones' }
+        it { is_expected.to eq 'mobile_phones' }
+      end
+
+      context 'non-aliased embeds one field' do
+        let(:key) { 'pass.exp' }
+        it { is_expected.to eq 'pass.exp' }
+      end
+
+      context 'aliased embeds one field' do
+        let(:key) { 'passport.expiration_date' }
+        it { is_expected.to eq 'pass.exp' }
+      end
+
+      context 'non-aliased embeds many field' do
+        let(:key) { 'mobile_phones.landline' }
+        it { is_expected.to eq 'mobile_phones.landline' }
+      end
+
+      context 'aliased embeds many field' do
+        let(:key) { 'phones.extension' }
+        it { is_expected.to eq 'mobile_phones.ext' }
+      end
+
+      context 'aliased multi-level embedded document' do
+        let(:key) { 'phones.extension' }
+        it { is_expected.to eq 'mobile_phones.ext' }
+      end
+
+      context 'non-aliased multi-level embedded document' do
+        let(:key) { 'phones.extension' }
+        it { is_expected.to eq 'mobile_phones.ext' }
+      end
+
+      context 'aliased multi-level embedded document field' do
+        let(:key) { 'mobile_phones.country_code.code' }
+        it { is_expected.to eq 'mobile_phones.country_code.code' }
+      end
+
+      context 'non-aliased multi-level embedded document field' do
+        let(:key) { 'phones.country_code.iso_alpha2_code' }
+        it { is_expected.to eq 'mobile_phones.country_code.iso' }
+      end
+
+      context 'when field is unknown' do
+        let(:key) { 'shenanigans' }
+        it { is_expected.to eq 'shenanigans' }
+      end
+
+      context 'when embedded field is unknown' do
+        let(:key) { 'phones.bamboozle' }
+        it { is_expected.to eq 'mobile_phones.bamboozle' }
+      end
+
+      context 'when multi-level embedded field is unknown' do
+        let(:key) { 'phones.bamboozle.brouhaha' }
+        it { is_expected.to eq 'mobile_phones.bamboozle.brouhaha' }
+      end
+    end
+
+    shared_examples_for 'pre-fix database_field_name' do
+      subject { Person.database_field_name(key) }
+
+      context 'non-aliased field name' do
+        let(:key) { 't' }
+        it { is_expected.to eq 't' }
+      end
+
+      context 'aliased field name' do
+        let(:key) { 'test' }
+        it { is_expected.to eq 't' }
+      end
+
+      context 'non-aliased embeds one relation' do
+        let(:key) { 'pass' }
+        it { is_expected.to eq 'pass' }
+      end
+
+      context 'aliased embeds one relation' do
+        let(:key) { 'passport' }
+        it { is_expected.to eq 'pass' }
+      end
+
+      context 'non-aliased embeds many relation' do
+        let(:key) { 'mobile_phones' }
+        it { is_expected.to eq 'mobile_phones' }
+      end
+
+      context 'aliased embeds many relation' do
+        let(:key) { 'phones' }
+        it { is_expected.to eq 'mobile_phones' }
+      end
+
+      context 'non-aliased embeds one field' do
+        let(:key) { 'pass.exp' }
+        it { is_expected.to eq 'pass.exp' }
+      end
+
+      context 'aliased embeds one field' do
+        let(:key) { 'passport.expiration_date' }
+        it { is_expected.to eq 'passport.expiration_date' }
+      end
+
+      context 'non-aliased embeds many field' do
+        let(:key) { 'mobile_phones.landline' }
+        it { is_expected.to eq 'mobile_phones.landline' }
+      end
+
+      context 'aliased embeds many field' do
+        let(:key) { 'phones.extension' }
+        it { is_expected.to eq 'phones.extension' }
+      end
+
+      context 'aliased multi-level embedded document' do
+        let(:key) { 'phones.extension' }
+        it { is_expected.to eq 'phones.extension' }
+      end
+
+      context 'non-aliased multi-level embedded document' do
+        let(:key) { 'phones.extension' }
+        it { is_expected.to eq 'phones.extension' }
+      end
+
+      context 'aliased multi-level embedded document field' do
+        let(:key) { 'mobile_phones.country_code.code' }
+        it { is_expected.to eq 'mobile_phones.country_code.code' }
+      end
+
+      context 'non-aliased multi-level embedded document field' do
+        let(:key) { 'phones.country_code.iso_alpha2_code' }
+        it { is_expected.to eq 'phones.country_code.iso_alpha2_code' }
+      end
+
+      context 'when field is unknown' do
+        let(:key) { 'shenanigans' }
+        it { is_expected.to eq 'shenanigans' }
+      end
+
+      context 'when embedded field is unknown' do
+        let(:key) { 'phones.bamboozle' }
+        it { is_expected.to eq 'phones.bamboozle' }
+      end
+
+      context 'when multi-level embedded field is unknown' do
+        let(:key) { 'phones.bamboozle.brouhaha' }
+        it { is_expected.to eq 'phones.bamboozle.brouhaha' }
+      end
+    end
+
+    context "when the broken_alias_handling is not set" do
+      config_override :broken_alias_handling, false
+
+      context 'given nil' do
+        subject { Person.database_field_name(nil) }
+        it { is_expected.to eq nil }
+      end
+
+      context 'given an empty String' do
+        subject { Person.database_field_name('') }
+        it { is_expected.to eq nil }
+      end
+
+      context 'given a String' do
+        subject { Person.database_field_name(key.to_s) }
+        it_behaves_like 'database_field_name'
+      end
+
+      context 'given a Symbol' do
+        subject { Person.database_field_name(key.to_sym) }
+        it_behaves_like 'database_field_name'
+      end
+    end
+
+    context "when the broken_alias_handling is set" do
+      config_override :broken_alias_handling, true
+
+      context 'given nil' do
+        subject { Person.database_field_name(nil) }
+        it { is_expected.to eq nil }
+      end
+
+      context 'given an empty String' do
+        subject { Person.database_field_name('') }
+        it { is_expected.to eq "" }
+      end
+
+      context 'given a String' do
+        subject { Person.database_field_name(key.to_s) }
+        it_behaves_like 'pre-fix database_field_name'
+      end
+
+      context 'given a Symbol' do
+        subject { Person.database_field_name(key.to_sym) }
+        it_behaves_like 'pre-fix database_field_name'
+      end
+    end
+
+    context 'when getting the database field name of a belongs_to associations' do
+      # These tests only apply when the flag is not set
+      config_override :broken_alias_handling, false
+
+      context "when the broken_alias_handling is not set" do
+        context "when the association is the last item" do
+          let(:name) do
+            Game.database_field_name("person")
+          end
+
+          it "gets the alias" do
+            expect(name).to eq("person_id")
+          end
+        end
+
+        context "when the association is not the last item" do
+          let(:name) do
+            Game.database_field_name("person.name")
+          end
+
+          it "gets the alias" do
+            expect(name).to eq("person.name")
+          end
+        end
+      end
+    end
+  end
+
+  describe "#get_field" do
+
+    let(:klass) { Person }
+    let(:field) { klass.cleanse_localized_field_names(field_name) }
+
+    context "when cleansing a field" do
+      let(:field_name) { "employer_id" }
+      it "returns the correct field name" do
+        expect(field).to eq(field_name)
+      end
+    end
+
+    context "when cleansing a localized field" do
+      let(:field_name) { "desc" }
+      it "returns the correct field name" do
+        expect(field).to eq(field_name)
+      end
+    end
+
+    context "when cleansing a translation field" do
+      let(:field_name) { "desc_translations" }
+      it "returns the correct field name" do
+        expect(field).to eq("desc")
+      end
+    end
+
+    context "when cleansing an existing translation field" do
+      let(:field_name) { "localized_translations" }
+      it "returns the correct field name" do
+        expect(field).to eq(field_name)
+      end
+    end
+
+    context "when cleansing an existing translation field with a _translations" do
+      let(:field_name) { "localized_translations_translations" }
+      it "returns the correct field name" do
+        expect(field).to eq("localized_translations")
+      end
+    end
+
+    context "when cleansing dotted translation field" do
+      config_override :broken_alias_handling, false
+      let(:field_name) { "passport.name_translations.asd" }
+      it "returns the correct field name" do
+        expect(field).to eq("pass.name.asd")
+      end
+    end
+
+    context "when cleansing dotted translation field as a symbol" do
+      config_override :broken_alias_handling, false
+      let(:field_name) { "passport.name_translations.asd".to_sym }
+      it "returns the correct field name" do
+        expect(field).to eq("pass.name.asd")
+      end
+    end
+
+    context "when cleansing dotted existing translation field" do
+      config_override :broken_alias_handling, false
+      let(:field_name) { "passport.localized_translations.asd" }
+      it "returns the correct field name" do
+        expect(field).to eq("pass.localized_translations.asd")
+      end
+    end
+
+    context "when cleansing aliased dotted translation field" do
+      let(:field_name) { "pass.name_translations.asd" }
+      it "returns the correct field name" do
+        expect(field).to eq("pass.name.asd")
       end
     end
   end