mongoid 7.0.13 → 8.0.8

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
 
@@ -107,7 +106,7 @@ describe Mongoid::Fields do
         context "when saving the new translations" do
 
           before do
-            product.save
+            product.save!
           end
 
           it "persists the changes" do
@@ -118,7 +117,7 @@ describe Mongoid::Fields do
 
             before do
               product.description_translations = { "en" => "overwritten" }
-              product.save
+              product.save!
             end
 
             it "persists the changes" do
@@ -149,7 +148,7 @@ describe Mongoid::Fields do
         context "when saving the new translations" do
 
           before do
-            dictionary.save
+            dictionary.save!
           end
 
           it "persists the changes" do
@@ -162,7 +161,7 @@ describe Mongoid::Fields do
 
             before do
               dictionary.description_translations = { "en" => "overwritten" }
-              dictionary.save
+              dictionary.save!
             end
 
             it "persists the changes" do
@@ -319,7 +318,7 @@ describe Mongoid::Fields do
       end
 
       it "converts to Mongoid::Boolean" do
-        expect(klass.field(:test, type: Boolean).type).to be(Mongoid::Boolean)
+        expect(klass.field(:test, type: Mongoid::Boolean).type).to be(Mongoid::Boolean)
       end
     end
 
@@ -394,6 +393,22 @@ describe Mongoid::Fields do
       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
@@ -401,7 +416,7 @@ describe Mongoid::Fields 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
@@ -416,7 +431,7 @@ describe Mongoid::Fields do
       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
@@ -425,11 +440,49 @@ describe Mongoid::Fields do
       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
+
     context "when the options are not valid" 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
@@ -514,6 +567,49 @@ describe Mongoid::Fields do
         end
       end
     end
+
+    context 'when the field is declared as BSON::Decimal128' do
+      let(:document) { Mop.create!(decimal128_field: BSON::Decimal128.new(Math::PI.to_s)).reload }
+
+      shared_context 'BSON::Decimal128 is BigDecimal' do
+        it 'should return a BigDecimal' do
+          expect(document.decimal128_field).to be_a BigDecimal
+        end
+      end
+
+      shared_context 'BSON::Decimal128 is BSON::Decimal128' do
+        it 'should return a BSON::Decimal128' do
+          expect(document.decimal128_field).to be_a BSON::Decimal128
+        end
+      end
+
+      it 'is declared as BSON::Decimal128' do
+        expect(Mop.fields['decimal128_field'].type).to be == BSON::Decimal128
+      end
+
+      context 'when BSON version <= 4' do
+        max_bson_version '4.99.99'
+        it_behaves_like 'BSON::Decimal128 is BSON::Decimal128'
+      end
+
+      context 'when BSON version >= 5' do
+        min_bson_version '5.0.0'
+
+        context 'when allow_bson5_decimal128 is false' do
+          config_override :allow_bson5_decimal128, false
+          it_behaves_like 'BSON::Decimal128 is BigDecimal'
+        end
+
+        context 'when allow_bson5_decimal128 is true' do
+          config_override :allow_bson5_decimal128, true
+          it_behaves_like 'BSON::Decimal128 is BSON::Decimal128'
+        end
+
+        context 'when allow_bson5_decimal128 is default' do
+          it_behaves_like 'BSON::Decimal128 is BigDecimal'
+        end
+      end
+    end
   end
 
   describe "#getter_before_type_cast" do
@@ -531,8 +627,144 @@ describe Mongoid::Fields do
     context "when the attribute has been assigned" do
 
       it "returns the attribute before type cast" do
-        person.age = "old"
-        expect(person.age_before_type_cast).to 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
@@ -580,14 +812,14 @@ 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
@@ -599,7 +831,7 @@ describe Mongoid::Fields do
 
         before do
           product.stores = [ "kadewe", nil ]
-          product.save
+          product.save!
         end
 
         it "allows the set of nil values" do
@@ -615,7 +847,7 @@ describe Mongoid::Fields do
 
         before do
           product.stores = [ "karstadt", "kadewe" ]
-          product.save
+          product.save!
         end
 
         it "reverses the values" do
@@ -688,6 +920,22 @@ describe Mongoid::Fields do
         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
@@ -792,7 +1040,8 @@ describe Mongoid::Fields do
       end
 
       it "does not return subclass defaults" do
-        expect(shape.pre_processed_defaults).to 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
 
@@ -803,7 +1052,8 @@ describe Mongoid::Fields do
       end
 
       it "has the parent and child defaults" do
-        expect(circle.pre_processed_defaults).to 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
@@ -822,32 +1072,30 @@ describe Mongoid::Fields do
           it "raises an error" do
             expect {
               Person.field(meth)
-            }.to raise_error(Mongoid::Errors::InvalidField)
+            }.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
 
-      before do
-        Mongoid.duplicate_fields_exception = true
-      end
-
-      after do
-        Mongoid.duplicate_fields_exception = false
-      end
-
-      it "raises an error" do
-        expect {
-          Person.field(:title)
-        }.to raise_error(Mongoid::Errors::InvalidField)
+        it "raises an error" do
+          expect {
+            Person.field(:title)
+          }.to raise_error(Mongoid::Errors::InvalidField)
+        end
       end
 
-      it "doesn't raise an error" do
-        expect {
-          Class.new(Person)
-        }.to_not raise_error
+      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
 
@@ -947,11 +1195,11 @@ describe Mongoid::Fields do
       end
 
       before do
-        Person.field :aliased, as: :alias, type: Boolean, overwrite: true
+        Person.field :aliased, as: :alias, type: Mongoid::Boolean, overwrite: true
       end
 
       it "uses the alias to write the attribute" do
-        (person.alias = expect(true)).to be true
+        expect(person.alias = true).to be true
       end
 
       it "uses the alias to read the attribute" do
@@ -963,7 +1211,7 @@ describe Mongoid::Fields do
       end
 
       it "uses the name to write the attribute" do
-        (person.aliased = expect(true)).to be true
+        expect(person.aliased = true).to be true
       end
 
       it "uses the name to read the attribute" do
@@ -1075,6 +1323,10 @@ describe Mongoid::Fields do
       it "does not return subclass fields" do
         expect(shape.fields.keys).to_not include("radius")
       end
+
+      it 'includes _type field' do
+        expect(shape.fields.keys).to include("_type")
+      end
     end
 
     context "on subclasses" do
@@ -1094,6 +1346,28 @@ describe Mongoid::Fields do
       it "includes the child fields" do
         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
 
@@ -1166,71 +1440,147 @@ describe Mongoid::Fields do
 
   context "when a field is defined as a big decimal" do
 
-    let(:band) do
-      Band.new(name: "Tool")
-    end
-
-    let(:decimal) do
-      BigDecimal("1000000.00")
-    end
-
-    context "when setting to a big decimal" do
+    context 'when Mongoid.map_big_decimal_to_decimal128 is false' do
+      config_override :map_big_decimal_to_decimal128, false
 
-      before do
-        band.sales = decimal
+      let(:band) do
+        Band.new(name: "Tool")
       end
 
-      it "properly persists as a string" do
-        expect(band.attributes["sales"]).to eq(decimal.to_s)
+      let(:decimal) do
+        BigDecimal("1000000.00")
       end
 
-      it "returns the proper big decimal" do
-        expect(band.sales).to eq(decimal)
+      context "when setting to a big decimal" do
+
+        before do
+          band.sales = decimal
+        end
+
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq(decimal.to_s)
+        end
+
+        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
+        before do
+          band.sales = decimal.to_s
+        end
+
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq(decimal.to_s)
+        end
+
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
+        end
       end
 
-      it "properly persists as a string" do
-        expect(band.attributes["sales"]).to eq(decimal.to_s)
+      context "when setting to an integer" do
+
+        before do
+          band.sales = decimal.to_i
+        end
+
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq("1000000")
+        end
+
+        it "returns the proper big decimal" do
+          expect(band.sales).to eq(decimal)
+        end
       end
 
-      it "returns the proper big decimal" do
-        expect(band.sales).to eq(decimal)
+      context "when setting to a float" do
+
+        before do
+          band.sales = decimal.to_f
+        end
+
+        it "properly persists as a string" do
+          expect(band.attributes["sales"]).to eq(decimal.to_s)
+        end
+
+        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 Mongoid.map_big_decimal_to_decimal128 is true' do
+      config_override :map_big_decimal_to_decimal128, true
 
-      before do
-        band.sales = decimal.to_i
+      let(:band) do
+        Band.new(name: "Tool")
       end
 
-      it "properly persists as a string" do
-        expect(band.attributes["sales"]).to eq("1000000")
+      let(:decimal) do
+        BigDecimal("1000000.00")
       end
 
-      it "returns the proper big decimal" do
-        expect(band.sales).to eq(decimal)
+      context "when setting to a big decimal" do
+
+        before do
+          band.sales = decimal
+        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
+          expect(band.sales).to eq(decimal)
+        end
       end
-    end
 
-    context "when setting to a float" do
+      context "when setting to a string" do
 
-      before do
-        band.sales = decimal.to_f
+        before do
+          band.sales = 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
+          expect(band.sales).to eq(decimal)
+        end
       end
 
-      it "properly persists as a string" do
-        expect(band.attributes["sales"]).to eq(decimal.to_s)
+      context "when setting to an integer" do
+
+        before do
+          band.sales = decimal.to_i
+        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
+          expect(band.sales).to eq(decimal)
+        end
       end
 
-      it "returns the proper big decimal" do
-        expect(band.sales).to eq(decimal)
+      context "when setting to a float" do
+
+        before do
+          band.sales = decimal.to_f
+        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
+          expect(band.sales).to eq(decimal)
+        end
       end
     end
   end
@@ -1238,7 +1588,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
@@ -1252,7 +1602,7 @@ describe Mongoid::Fields do
     before do
       person.map = map
       person.map["stack1"].reverse!
-      person.save
+      person.save!
     end
 
     it "properly updates the hash" do
@@ -1311,4 +1661,350 @@ describe Mongoid::Fields do
       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
 end