mongoid 8.1.8 → 9.0.0

data/spec/mongoid/fields/foreign_key_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -496,181 +497,343 @@ describe Mongoid::Fields::ForeignKey do
     end
   end
 
-  describe "#mongoize" do
+  describe '#mongoize' do
+    let(:field) do
+      described_class.new(
+        :vals,
+        type: type,
+        default: [],
+        identity: true,
+        association: association,
+        overwrite: true
+      )
+    end
+    let(:association) { Game.relations['person'] }
+    subject(:mongoized) { field.mongoize(object) }
+
+    context 'type is Array' do
+      let(:type) { Array }
+
+      context 'when the object is a BSON::ObjectId' do
+        let(:object) { BSON::ObjectId.new }
+
+        it 'returns the object id as an array' do
+          expect(mongoized).to eq([object])
+        end
+      end
+
+      context 'when the object is an Array of BSON::ObjectId' do
+        let(:object) { [BSON::ObjectId.new] }
+
+        it 'returns the object ids' do
+          expect(mongoized).to eq(object)
+        end
+      end
+
+      context 'when the object is a String which is a legal object id' do
+        let(:object) { BSON::ObjectId.new.to_s }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq([BSON::ObjectId.from_string(object)])
+        end
+      end
+
+      context 'when the object is a String which is not a legal object id' do
+        let(:object) { 'blah' }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq(%w[blah])
+        end
+      end
+
+      context 'when the object is a blank String' do
+        let(:object) { '' }
+
+        it 'returns an empty array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is nil' do
+        let(:object) { nil }
+
+        it 'returns an empty array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is Array of Strings which are legal object ids' do
+        let(:object) { [BSON::ObjectId.new.to_s] }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq([BSON::ObjectId.from_string(object.first)])
+        end
+      end
+
+      context 'when the object is Array of Strings which are not legal object ids' do
+        let(:object) { %w[blah] }
+
+        it 'returns the Array' do
+          expect(mongoized).to eq(%w[blah])
+        end
+      end
+
+      context 'when the object is Array of Strings which are blank' do
+        let(:object) { ['', ''] }
+
+        it 'returns an empty Array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is Array of nils' do
+        let(:object) { [nil, nil, nil] }
+
+        it 'returns an empty Array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is an empty Array' do
+        let(:object) { [] }
+
+        it 'returns an empty Array' do
+          expect(mongoized).to eq([])
+        end
 
-    context "when the type is array" do
+        it 'returns the same instance' do
+          expect(mongoized).to equal(object)
+        end
+      end
 
-      context "when the array is object ids" do
+      context 'when the object is a Set' do
+        let(:object) { Set['blah'] }
 
-        let(:association) do
-          Game.relations["person"]
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq(%w[blah])
         end
+      end
 
-        let(:field) do
-          described_class.new(
-            :vals,
-            type: Array,
-            default: [],
-            identity: true,
-            association: association,
+      context 'when foreign key is a String' do
+        before do
+          Person.field(:_id, type: String, overwrite: true)
+        end
+
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
             overwrite: true
           )
         end
 
-        context "when provided nil" do
+        context 'when the object is a String' do
+          let(:object) { %w[1] }
 
-          it "returns an empty array" do
-            expect(field.mongoize(nil)).to be_empty
+          it 'returns String' do
+            expect(mongoized).to eq(object)
           end
         end
 
-        context "when provided an empty array" do
+        context 'when the object is a BSON::ObjectId' do
+          let(:object) { [BSON::ObjectId.new] }
 
-          let(:array) do
-            []
+          it 'converts to String' do
+            expect(mongoized).to eq([object.first.to_s])
           end
+        end
 
-          it "returns an empty array" do
-            expect(field.mongoize(array)).to eq(array)
-          end
+        context 'when the object is an Integer' do
+          let(:object) { [1] }
 
-          it "returns the same instance" do
-            expect(field.mongoize(array)).to equal(array)
+          it 'converts to String' do
+            expect(mongoized).to eq(%w[1])
           end
         end
+      end
 
-        context "when using object ids" do
+      context 'when foreign key is an Integer' do
+        before do
+          Person.field(:_id, type: Integer, overwrite: true)
+        end
 
-          let(:object_id) do
-            BSON::ObjectId.new
-          end
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
+            overwrite: true
+          )
+        end
 
-          it "performs conversion on the ids if strings" do
-            expect(field.mongoize([object_id.to_s])).to eq([object_id])
+        context 'when the object is a String' do
+          let(:object) { %w[1] }
+
+          it 'converts to Integer' do
+            expect(mongoized).to eq([1])
           end
         end
 
-        context "when not using object ids" do
+        context 'when the object is an Integer' do
+          let(:object) { [1] }
 
-          let(:object_id) do
-            BSON::ObjectId.new
+          it 'returns Integer' do
+            expect(mongoized).to eq([1])
           end
+        end
+      end
+    end
 
-          before do
-            Person.field(
-              :_id,
-              type: String,
-              pre_processed: true,
-              default: ->{ BSON::ObjectId.new.to_s },
-              overwrite: true
-            )
-          end
+    context 'type is Set' do
+      let(:type) { Set }
 
-          after do
-            Person.field(
-              :_id,
-              type: BSON::ObjectId,
-              pre_processed: true,
-              default: ->{ BSON::ObjectId.new },
-              overwrite: true
-            )
-          end
+      context 'when the object is an Array of BSON::ObjectId' do
+        let(:object) { [BSON::ObjectId.new] }
 
-          it "does not convert" do
-            expect(field.mongoize([object_id.to_s])).to eq([object_id.to_s])
-          end
+        it 'returns the object ids' do
+          expect(mongoized).to eq(object)
+        end
+      end
+
+      context 'when the object is a Set of BSON::ObjectId' do
+        let(:object) { Set[BSON::ObjectId.new] }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq([object.first])
         end
       end
     end
 
-    context "when the type is object" do
+    context 'type is Object' do
+      let(:type) { Object }
 
-      context "when the array is object ids" do
+      context 'when the object is a BSON::ObjectId' do
+        let(:object) { BSON::ObjectId.new }
 
-        let(:association) do
-          Game.relations['person']
+        it 'returns the object id' do
+          expect(mongoized).to eq(object)
         end
+      end
 
-        let(:field) do
-          described_class.new(
-            :vals,
-            type: Object,
-            default: nil,
-            identity: true,
-            association: association,
-            overwrite: true
-          )
+      context 'when the object is a String which is a legal object id' do
+        let(:object) { BSON::ObjectId.new.to_s }
+
+        it 'returns the object id' do
+          expect(mongoized).to eq(BSON::ObjectId.from_string(object))
         end
+      end
 
-        context "when using object ids" do
+      context 'when the object is a String which is not a legal object id' do
+        let(:object) { 'blah' }
 
-          let(:object_id) do
-            BSON::ObjectId.new
-          end
+        it 'returns the string' do
+          expect(mongoized).to eq('blah')
+        end
+      end
 
-          it "performs conversion on the ids if strings" do
-            expect(field.mongoize(object_id.to_s)).to eq(object_id)
-          end
+      context 'when the String is blank' do
+        let(:object) { '' }
+
+        it 'returns nil' do
+          expect(mongoized).to be_nil
+        end
+      end
+
+      context 'when the object is nil' do
+        let(:object) { '' }
+
+        it 'returns nil' do
+          expect(mongoized).to be_nil
         end
+      end
 
-        context "when not using object ids" do
+      context 'when object is an empty Array' do
+        let(:object) { [] }
 
-          context "when using strings" do
+        it 'returns an empty array' do
+          expect(mongoized).to eq([])
+        end
+      end
 
-            context "when provided a string" do
+      context 'when the object is a Set' do
+        let(:object) { Set['blah'] }
 
-              let(:object_id) do
-                BSON::ObjectId.new
-              end
+        it 'returns the set' do
+          expect(mongoized).to eq(Set['blah'])
+        end
+      end
 
-              before do
-                Person.field(
-                  :_id,
-                  type: String,
-                  pre_processed: true,
-                  default: ->{ BSON::ObjectId.new.to_s },
-                  overwrite: true
-                )
-              end
+      context 'when foreign key is a String' do
+        before do
+          Person.field(:_id, type: String, overwrite: true)
+        end
 
-              after do
-                Person.field(
-                  :_id,
-                  type: BSON::ObjectId,
-                  pre_processed: true,
-                  default: ->{ BSON::ObjectId.new },
-                  overwrite: true
-                )
-              end
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
+            overwrite: true
+          )
+        end
 
-              it "does not convert" do
-                expect(field.mongoize(object_id.to_s)).to eq(object_id.to_s)
-              end
-            end
+        context 'when the object is a String' do
+          let(:object) { '1' }
+
+          it 'returns String' do
+            expect(mongoized).to eq(object)
+          end
+        end
+
+        context 'when the object is a BSON::ObjectId' do
+          let(:object) { BSON::ObjectId.new }
+
+          it 'converts to String' do
+            expect(mongoized).to eq(object.to_s)
           end
+        end
 
-          context "when using integers" do
+        context 'when the object is an Integer' do
+          let(:object) { 1 }
 
-            context "when provided a string" do
+          it 'converts to String' do
+            expect(mongoized).to eq('1')
+          end
+        end
+      end
 
-              before do
-                Person.field(:_id, type: Integer, overwrite: true)
-              end
+      context 'when foreign key is an Integer' do
+        before do
+          Person.field(:_id, type: Integer, overwrite: true)
+        end
 
-              after do
-                Person.field(
-                  :_id,
-                  type: BSON::ObjectId,
-                  pre_processed: true,
-                  default: ->{ BSON::ObjectId.new },
-                  overwrite: true
-                )
-              end
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
+            overwrite: true
+          )
+        end
 
-              it "converts the string to an integer" do
-                expect(field.mongoize("1")).to eq(1)
-              end
-            end
+        context 'when the object is a String' do
+          let(:object) { '1' }
+
+          it 'converts to Integer' do
+            expect(mongoized).to eq(1)
+          end
+        end
+
+        context 'when the object is an Integer' do
+          let(:object) { 1 }
+
+          it 'returns Integer' do
+            expect(mongoized).to eq(object)
           end
         end
       end

data/spec/mongoid/fields/localized_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/fields/standard_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/fields_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
 describe Mongoid::Fields do
-  config_override :use_activesupport_time_zone, false
 
   describe "#\{field}_translations" do
 
@@ -923,6 +923,34 @@ describe Mongoid::Fields do
         expect(product.attributes_before_type_cast["price"]).to eq(1)
       end
     end
+
+    context "when assigning a hash" do
+      let(:person) { Person.create!(map: { x: 1 }) }
+
+      it "is a BSON::Document" do
+        expect(person.map).to be_a(BSON::Document)
+      end
+
+      it "has the correct contents" do
+        expect(person.map).to eq({ "x" => 1 })
+      end
+    end
+
+    context "when loading a hash from the db" do
+      before do
+        Person.create!(map: { x: 1 })
+      end
+
+      let(:person) { Person.first }
+
+      it "is a BSON::Document" do
+        expect(person.map).to be_a(BSON::Document)
+      end
+
+      it "has the correct contents" do
+        expect(person.map).to eq({ "x" => 1 })
+      end
+    end
   end
 
   describe "#defaults" do
@@ -1089,7 +1117,7 @@ describe Mongoid::Fields do
     context "when the field is a time" do
 
       let!(:time) do
-        Time.now
+        Time.find_zone('UTC').parse('2023-03-03 10:30:53')
       end
 
       let!(:person) do
@@ -1097,10 +1125,11 @@ describe Mongoid::Fields do
       end
 
       context "when reading the field" do
-        time_zone_override "Berlin"
+        time_zone_override 'Europe/Berlin'
 
         it "performs the necessary time conversions" do
-          expect(person.lunch_time.to_s).to eq(time.getlocal.to_s)
+          expect(person.lunch_time.to_s).to eq('2023-03-03 11:30:53 +0100')
+          expect(person.lunch_time.time_zone.name).to eq('Europe/Berlin')
         end
       end
     end
@@ -1840,77 +1869,45 @@ describe Mongoid::Fields do
       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 '' }
-      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 'database_field_name'
-      end
-
-      context 'given a Symbol' do
-        subject { Person.database_field_name(key.to_sym) }
-        it_behaves_like 'database_field_name'
-      end
+    context 'given nil' do
+      subject { Person.database_field_name(nil) }
+      it { is_expected.to eq nil }
     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 '' }
-      end
-
-      context 'given an empty String' do
-        subject { Person.database_field_name('') }
-        it { is_expected.to eq "" }
-      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 'pre-fix database_field_name'
-      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 'pre-fix database_field_name'
-      end
+    context 'given a Symbol' do
+      subject { Person.database_field_name(key.to_sym) }
+      it_behaves_like 'database_field_name'
     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
+      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
+        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
+      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
+        it "gets the alias" do
+          expect(name).to eq("person.name")
         end
       end
     end
@@ -1957,7 +1954,6 @@ describe Mongoid::Fields do
     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")
@@ -1965,7 +1961,6 @@ describe Mongoid::Fields do
     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")
@@ -1973,7 +1968,6 @@ describe Mongoid::Fields do
     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")