mongoid 8.1.6 → 9.0.0

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")

data/spec/mongoid/findable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -900,31 +901,15 @@ describe Mongoid::Findable do
 
   context 'when Mongoid is configured to use activesupport time zone' do
     config_override :use_utc, false
-    config_override :use_activesupport_time_zone, true
     time_zone_override "Asia/Kolkata"
 
     let!(:time) do
-      Time.zone.now.tap do |t|
+      Time.current.tap do |t|
         User.create!(last_login: t, name: 'Tom')
       end
     end
 
-    context 'when distinct does not demongoize' do
-      config_override :legacy_pluck_distinct, true
-
-      let(:distinct) do
-        User.distinct(:last_login).first
-      end
-
-      it 'uses activesupport time zone' do
-        distinct.should be_a(ActiveSupport::TimeWithZone)
-        expect(distinct.to_s).to eql(time.in_time_zone('Asia/Kolkata').to_s)
-      end
-    end
-
     context 'when distinct demongoizes' do
-      config_override :legacy_pluck_distinct, false
-
       let(:distinct) do
         User.distinct(:last_login).first
       end
@@ -942,48 +927,4 @@ describe Mongoid::Findable do
       expect(User.distinct(:name)).to match_array(['Tom'])
     end
   end
-
-  context 'when Mongoid is not configured to use activesupport time zone' do
-    config_override :use_utc, true
-    config_override :use_activesupport_time_zone, false
-
-    let!(:time) do
-      Time.now.tap do |t|
-        User.create!(last_login: t, name: 'Tom')
-      end
-    end
-
-    context 'when distinct does not demongoize' do
-      config_override :legacy_pluck_distinct, true
-
-      let(:distinct) do
-        User.distinct(:last_login).first
-      end
-
-      it 'uses utc' do
-        distinct.should be_a(Time)
-        expect(distinct.to_s).to eql(time.utc.to_s)
-      end
-    end
-
-    context 'when distinct demongoizes' do
-      config_override :legacy_pluck_distinct, false
-
-      let(:distinct) do
-        User.distinct(:last_login).first
-      end
-
-      it 'uses utc' do
-        distinct.should be_a(DateTime)
-        # Time and DateTime have different stringifications:
-        # 2022-03-16T21:12:32+00:00
-        # 2022-03-16 21:12:32 UTC
-        expect(distinct.to_s).to eql(time.utc.to_datetime.to_s)
-      end
-    end
-
-    it 'loads other fields accurately' do
-      expect(User.distinct(:name)).to match_array(['Tom'])
-    end
-  end
 end

data/spec/mongoid/indexable/specification_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -80,25 +81,143 @@ describe Mongoid::Indexable::Specification do
 
   describe "#initialize" do
 
-    let(:spec) do
-      described_class.new(
-        Band,
-        { name: 1, title: 1, years: -1 },
-        background: true,
-        unique: true
-      )
+    context "standard case" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1 },
+          background: true,
+          unique: true
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(background: true, unique: true)
+      end
     end
 
-    it "sets the class" do
-      expect(spec.klass).to eq(Band)
+    context "with aliased field options" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1, d: 1 },
+          partial_filter_expression: {
+            name: { '$exists' => true },
+            years: { '$gt' => 5 },
+            d: { '$eq' => false },
+            '$and' => [
+              { views: { '$gt' => 100 } },
+              { years: { '$lte' => 50 } }
+            ]
+          },
+          weights: {
+            name: 1,
+            years: 2
+          },
+          wildcard_projection: {
+            years: 1
+          }
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1, deleted: 1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(partial_filter_expression: {
+                                     name: { '$exists' => true },
+                                     y: { '$gt' => 5 },
+                                     deleted: { '$eq' => false },
+                                     '$and': [
+                                       { views: { '$gt' => 100 } },
+                                       { y: { '$lte' => 50 } }
+                                     ]
+                                   },
+                                   weights: {
+                                     name: 1,
+                                     y: 2
+                                   },
+                                   wildcard_projection: {
+                                     y: 1
+                                   })
+      end
     end
 
-    it "normalizes the key" do
-      expect(spec.key).to eq(name: 1, title: 1, y: -1)
+    context "with aliased field options nested inside $ operators" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1 },
+          partial_filter_expression: {
+            '$foo' => { years: { '$lte' => 50 } },
+            '$bar' => [
+              { views: { '$gt' => 100 } },
+              { years: { '$lte' => 50 } }
+            ]
+          }
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(partial_filter_expression: {
+          '$foo': { y: { '$lte' => 50 } },
+          '$bar': [
+            { views: { '$gt' => 100 } },
+            { y: { '$lte' => 50 } }
+          ]
+        })
+      end
     end
 
-    it "normalizes the options" do
-      expect(spec.options).to eq(background: true, unique: true)
+    context "with aliased field options double-nested" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1 },
+          partial_filter_expression: {
+            '$foo' => { years: { years: { '$lte' => 50 } } },
+          }
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(partial_filter_expression: {
+          '$foo': { y: { years: { '$lte' => 50 } } },
+        })
+      end
     end
   end