mongoid 8.0.13 → 8.1.0

data/spec/mongoid/extensions/hash_spec.rb

@@ -178,7 +178,7 @@ describe Mongoid::Extensions::Hash do
 
         it "moves the non hash values under the provided key" do
           expect(consolidated).to eq({
-            "$set" => { 'name' => "Tool", likes: 10 }, "$inc" => { 'plays' => 1 }
+            "$set" => { name: "Tool", likes: 10 }, "$inc" => { plays: 1 }
           })
         end
       end
@@ -195,7 +195,7 @@ describe Mongoid::Extensions::Hash do
 
         it "moves the non hash values under the provided key" do
           expect(consolidated).to eq({
-            "$set" => { likes: 10, 'name' => "Tool" }, "$inc" => { 'plays' => 1 }
+            "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
           })
         end
       end
@@ -213,7 +213,7 @@ describe Mongoid::Extensions::Hash do
 
       it "moves the non hash values under the provided key" do
         expect(consolidated).to eq({
-          "$set" => { likes: 10, name: "Tool" }, "$inc" => { 'plays' => 1 }
+          "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
         })
       end
     end
@@ -497,240 +497,4 @@ describe Mongoid::Extensions::Hash do
 
     it_behaves_like 'unsatisfiable criteria method'
   end
-
-  describe '#to_criteria' do
-    subject(:criteria) { hash.to_criteria }
-
-    context 'when klass is specified' do
-      let(:hash) do
-        { klass: Band, where: { name: 'Songs Ohia' } }
-      end
-
-      it 'returns a criteria' do
-        expect(criteria).to be_a(Mongoid::Criteria)
-      end
-
-      it 'sets the klass' do
-        expect(criteria.klass).to eq(Band)
-      end
-
-      it 'sets the selector' do
-        expect(criteria.selector).to eq({ 'name' => 'Songs Ohia' })
-      end
-    end
-
-    context 'when klass is missing' do
-      let(:hash) do
-        { where: { name: 'Songs Ohia' } }
-      end
-
-      it 'returns a criteria' do
-        expect(criteria).to be_a(Mongoid::Criteria)
-      end
-
-      it 'has klass nil' do
-        expect(criteria.klass).to be_nil
-      end
-
-      it 'sets the selector' do
-        expect(criteria.selector).to eq({ 'name' => 'Songs Ohia' })
-      end
-    end
-
-    context 'with allowed methods' do
-      context 'when using multiple query methods' do
-        let(:hash) do
-          {
-            klass: Band,
-            where: { active: true },
-            limit: 10,
-            skip: 5,
-            order_by: { name: 1 }
-          }
-        end
-
-        it 'applies all methods successfully' do
-          expect(criteria.selector).to eq({ 'active' => true })
-          expect(criteria.options[:limit]).to eq(10)
-          expect(criteria.options[:skip]).to eq(5)
-          expect(criteria.options[:sort]).to eq({ 'name' => 1 })
-        end
-      end
-
-      context 'when using query selector methods' do
-        let(:hash) do
-          {
-            klass: Band,
-            gt: { members: 2 },
-            in: { genre: ['rock', 'metal'] }
-          }
-        end
-
-        it 'applies selector methods' do
-          expect(criteria.selector['members']).to eq({ '$gt' => 2 })
-          expect(criteria.selector['genre']).to eq({ '$in' => ['rock', 'metal'] })
-        end
-      end
-
-      context 'when using aggregation methods' do
-        let(:hash) do
-          {
-            klass: Band,
-            project: { name: 1, members: 1 }
-          }
-        end
-
-        it 'applies aggregation methods' do
-          expect { criteria }.not_to raise_error
-        end
-      end
-    end
-
-    context 'with disallowed methods' do
-      context 'when attempting to call create' do
-        let(:hash) do
-          { klass: Band, create: { name: 'Malicious' } }
-        end
-
-        it 'raises ArgumentError' do
-          expect { criteria }.to raise_error(ArgumentError, "Method 'create' is not allowed in to_criteria")
-        end
-      end
-
-      context 'when attempting to call create!' do
-        let(:hash) do
-          { klass: Band, 'create!': { name: 'Malicious' } }
-        end
-
-        it 'raises ArgumentError' do
-          expect { criteria }.to raise_error(ArgumentError, "Method 'create!' is not allowed in to_criteria")
-        end
-      end
-
-      context 'when attempting to call build' do
-        let(:hash) do
-          { klass: Band, build: { name: 'Malicious' } }
-        end
-
-        it 'raises ArgumentError' do
-          expect { criteria }.to raise_error(ArgumentError, "Method 'build' is not allowed in to_criteria")
-        end
-      end
-
-      context 'when attempting to call find' do
-        let(:hash) do
-          { klass: Band, find: 'some_id' }
-        end
-
-        it 'raises ArgumentError' do
-          expect { criteria }.to raise_error(ArgumentError, "Method 'find' is not allowed in to_criteria")
-        end
-      end
-
-      context 'when attempting to call execute_or_raise' do
-        let(:hash) do
-          { klass: Band, execute_or_raise: ['id1', 'id2'] }
-        end
-
-        it 'raises ArgumentError' do
-          expect { criteria }.to raise_error(ArgumentError, "Method 'execute_or_raise' is not allowed in to_criteria")
-        end
-      end
-
-      context 'when attempting to call new' do
-        let(:hash) do
-          { klass: Band, new: { name: 'Test' } }
-        end
-
-        it 'raises ArgumentError' do
-          expect { criteria }.to raise_error(ArgumentError, "Method 'new' is not allowed in to_criteria")
-        end
-      end
-
-      context 'when allowed method is combined with disallowed method' do
-        let(:hash) do
-          {
-            klass: Band,
-            where: { active: true },
-            create: { name: 'Malicious' }
-          }
-        end
-
-        it 'raises ArgumentError before executing any methods' do
-          expect { criteria }.to raise_error(ArgumentError, "Method 'create' is not allowed in to_criteria")
-        end
-      end
-    end
-
-    context 'security validation' do
-      # This test ensures that ALL public methods not in the allowlist are blocked
-      it 'blocks all dangerous public methods' do
-        dangerous_methods = %i[
-          build create create! new
-          find find_or_create_by find_or_create_by! find_or_initialize_by
-          first_or_create first_or_create! first_or_initialize
-          execute_or_raise multiple_from_db for_ids
-          documents= inclusions= scoping_options=
-          initialize freeze as_json
-        ]
-
-        dangerous_methods.each do |method|
-          hash = { klass: Band, method => 'arg' }
-          expect { hash.to_criteria }.to raise_error(
-            ArgumentError,
-            "Method '#{method}' is not allowed in to_criteria"
-          ), "Expected method '#{method}' to be blocked but it was allowed"
-        end
-      end
-
-      it 'blocks dangerous inherited methods from Object' do
-        # Critical security test: block send, instance_eval, etc.
-        inherited_dangerous = %i[
-          send __send__ instance_eval instance_exec
-          instance_variable_set method
-        ]
-
-        inherited_dangerous.each do |method|
-          hash = { klass: Band, method => 'arg' }
-          expect { hash.to_criteria }.to raise_error(
-            ArgumentError,
-            "Method '#{method}' is not allowed in to_criteria"
-          ), "Expected inherited method '#{method}' to be blocked"
-        end
-      end
-
-      it 'blocks Enumerable execution methods' do
-        # to_criteria should build queries, not execute them
-        enumerable_methods = %i[each map select count sum]
-
-        enumerable_methods.each do |method|
-          hash = { klass: Band, method => 'arg' }
-          expect { hash.to_criteria }.to raise_error(
-            ArgumentError,
-            "Method '#{method}' is not allowed in to_criteria"
-          ), "Expected Enumerable method '#{method}' to be blocked"
-        end
-      end
-
-      it 'allows all whitelisted methods' do
-        # Sample of allowed methods from each category
-        allowed_sample = {
-          where: { name: 'Test' },      # Query selector
-          limit: 10,                     # Query option
-          skip: 5,                       # Query option
-          gt: { age: 18 },              # Query selector
-          in: { status: ['active'] },   # Query selector
-          ascending: :name,              # Sorting
-          includes: :notes,            # Eager loading
-          merge: { klass: Band },        # Merge
-        }
-
-        allowed_sample.each do |method, args|
-          hash = { klass: Band, method => args }
-          expect { hash.to_criteria }.not_to raise_error,
-            "Expected method '#{method}' to be allowed but it was blocked"
-        end
-      end
-    end
-  end
 end

data/spec/mongoid/extensions/time_spec.rb

@@ -50,14 +50,7 @@ describe Mongoid::Extensions::Time do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
-
-        before do
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
+        time_zone_override "Stockholm"
 
         context "when demongoizing a Time" do
 
@@ -123,19 +116,12 @@ describe Mongoid::Extensions::Time do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
+        time_zone_override "Stockholm"
 
         let(:time) do
           Time.utc(2010, 11, 19, 0, 30)
         end
 
-        before do
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
-
         it "returns utc" do
           expect(Time.demongoize(time)).to eq(
             ActiveSupport::TimeZone['UTC'].local(2010, 11, 19, 0, 30)
@@ -855,20 +841,13 @@ describe Mongoid::Extensions::Time do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
+        # if this is actually your time zone, the following tests are useless
+        time_zone_override "Stockholm"
 
         let(:datetime) do
           DateTime.new(2010, 11, 19)
         end
 
-        before do
-          # if this is actually your time zone, the following tests are useless
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
-
         it "assumes the given time is local" do
           expect(Time.mongoize(datetime)).to eq(
             Time.utc(2010, 11, 19)
@@ -945,20 +924,13 @@ describe Mongoid::Extensions::Time do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
+        # if this is actually your time zone, the following tests are useless
+        time_zone_override "Stockholm"
 
         let(:date) do
           Date.new(2010, 11, 19)
         end
 
-        before do
-          # if this is actually your time zone, the following tests are useless
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
-
         it "assumes the given time is local" do
           expect(Time.mongoize(date)).to eq(Time.utc(2010, 11, 18, 23))
         end
@@ -977,15 +949,8 @@ describe Mongoid::Extensions::Time do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
-
-        before do
-          # if this is actually your time zone, the following tests are useless
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
+        # if this is actually your time zone, the following tests are useless
+        time_zone_override "Stockholm"
 
         it "assumes the given time is local" do
           expect(Time.mongoize(array)).to eq(

data/spec/mongoid/extensions/time_with_zone_spec.rb

@@ -50,14 +50,7 @@ describe Mongoid::Extensions::TimeWithZone do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
-
-        before do
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
+        time_zone_override "Stockholm"
 
         it "returns an ActiveSupport::TimeWithZone" do
           expect(ActiveSupport::TimeWithZone.demongoize(time).class).to eq(ActiveSupport::TimeWithZone)
@@ -113,19 +106,12 @@ describe Mongoid::Extensions::TimeWithZone do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
+        time_zone_override "Stockholm"
 
         let(:time) do
           Time.utc(2010, 11, 19, 0, 30)
         end
 
-        before do
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
-
         it "returns utc" do
           expect(ActiveSupport::TimeWithZone.demongoize(time)).to eq(
             ActiveSupport::TimeZone['UTC'].local(2010, 11, 19, 0, 30)
@@ -203,15 +189,8 @@ describe Mongoid::Extensions::TimeWithZone do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
-
-        before do
-          # if this is actually your time zone, the following tests are useless
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
+        # if this is actually your time zone, the following tests are useless
+        time_zone_override "Stockholm"
 
         context "when the local time is not observing daylight saving" do
 
@@ -247,20 +226,12 @@ describe Mongoid::Extensions::TimeWithZone do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
+        time_zone_override "Stockholm"
 
         let(:datetime) do
           DateTime.new(2010, 11, 19)
         end
 
-        before do
-          # if this is actually your time zone, the following tests are useless
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
-
         it "assumes the given time is local" do
           expect(ActiveSupport::TimeWithZone.mongoize(datetime)).to eq(
             Time.utc(2010, 11, 19)
@@ -317,20 +288,12 @@ describe Mongoid::Extensions::TimeWithZone do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
+        time_zone_override "Stockholm"
 
         let(:date) do
           Date.new(2010, 11, 19)
         end
 
-        before do
-          # if this is actually your time zone, the following tests are useless
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
-
         it "assumes the given time is local" do
           expect(ActiveSupport::TimeWithZone.mongoize(date)).to eq(Time.utc(2010, 11, 18, 23))
         end
@@ -349,15 +312,7 @@ describe Mongoid::Extensions::TimeWithZone do
 
       context "when using the ActiveSupport time zone" do
         config_override :use_activesupport_time_zone, true
-
-        before do
-          # if this is actually your time zone, the following tests are useless
-          Time.zone = "Stockholm"
-        end
-
-        after do
-          Time.zone = nil
-        end
+        time_zone_override "Stockholm"
 
         it "assumes the given time is local" do
           expect(ActiveSupport::TimeWithZone.mongoize(array)).to eq(

data/spec/mongoid/fields/localized_spec.rb

@@ -81,16 +81,12 @@ describe Mongoid::Fields::Localized do
       end
 
       context "when a locale is provided" do
+        with_default_i18n_configs
 
         before do
-          I18n.enforce_available_locales = false
           ::I18n.locale = :de
         end
 
-        after do
-          ::I18n.locale = :en
-        end
-
         context "when the value exists" do
 
           let(:value) do
@@ -128,6 +124,7 @@ describe Mongoid::Fields::Localized do
         context "when the value does not exist" do
 
           context "when not using fallbacks" do
+            require_no_fallbacks
 
             let(:value) do
               field.demongoize({ "en" => "testing" })
@@ -139,8 +136,7 @@ describe Mongoid::Fields::Localized do
           end
 
           context "when using fallbacks" do
-
-            with_i18n_fallbacks
+            require_fallbacks
 
             context "when fallbacks are defined" do
 
@@ -271,15 +267,12 @@ describe Mongoid::Fields::Localized do
       end
 
       context "when a locale is provided" do
+        with_default_i18n_configs
 
         before do
           ::I18n.locale = :de
         end
 
-        after do
-          ::I18n.locale = :en
-        end
-
         context "when the value exists" do
 
           let(:value) do
@@ -305,10 +298,10 @@ describe Mongoid::Fields::Localized do
           end
 
           context "when using fallbacks" do
-
-            with_i18n_fallbacks
+            require_fallbacks
 
             context "when fallbacks are defined" do
+              with_default_i18n_configs
 
               before do
                 ::I18n.fallbacks[:de] = [ :de, :en, :es ]
@@ -367,6 +360,7 @@ describe Mongoid::Fields::Localized do
             end
 
             context "when no fallbacks are defined" do
+              with_default_i18n_configs
 
               before do
                 ::I18n.fallbacks[:de] = [ :de ]
@@ -406,15 +400,12 @@ describe Mongoid::Fields::Localized do
       end
 
       context "when a locale is provided" do
+        with_default_i18n_configs
 
         before do
           ::I18n.locale = :de
         end
 
-        after do
-          ::I18n.locale = :en
-        end
-
         let(:value) do
           field.mongoize("This is a test")
         end
@@ -443,15 +434,12 @@ describe Mongoid::Fields::Localized do
       end
 
       context "when a locale is provided" do
+        with_default_i18n_configs
 
         before do
           ::I18n.locale = :de
         end
 
-        after do
-          ::I18n.locale = :en
-        end
-
         let(:value) do
           field.mongoize("100")
         end
@@ -462,16 +450,12 @@ describe Mongoid::Fields::Localized do
       end
 
       context 'when the type is Boolean' do
+        with_default_i18n_configs
 
         before do
-          I18n.enforce_available_locales = false
           ::I18n.locale = :de
         end
 
-        after do
-          ::I18n.locale = :en
-        end
-
         context "when the value is false" do
 
           let(:field) do
@@ -503,12 +487,12 @@ describe Mongoid::Fields::Localized do
         end
 
         context "when fallbacks are defined" do
-
-          with_i18n_fallbacks
+          require_fallbacks
 
           context "when the lookup does not need to use fallbacks" do
 
             context "when the value is false" do
+              with_default_i18n_configs
 
               before do
                 ::I18n.fallbacks[:de] = [:en, :es]
@@ -528,6 +512,7 @@ describe Mongoid::Fields::Localized do
             end
 
             context "when the value is true" do
+              with_default_i18n_configs
 
               before do
                 ::I18n.fallbacks[:de] = [:en, :es]
@@ -550,4 +535,37 @@ describe Mongoid::Fields::Localized do
       end
     end
   end
+
+  describe "localize: :present" do
+
+    let(:field) do
+      described_class.new(:description, localize: :present, type: String)
+    end
+
+    context "when setting the localize to present" do
+
+      it "is localized?" do
+        expect(field.localized?).to be true
+      end
+
+      it "is localize_present?" do
+        expect(field.localize_present?).to be true
+      end
+    end
+
+    context "when localize is not localize_present" do
+
+      let(:field) do
+        described_class.new(:description, localize: true, type: String)
+      end
+
+      it "is localized?" do
+        expect(field.localized?).to be true
+      end
+
+      it "is not localize_present?" do
+        expect(field.localize_present?).to be false
+      end
+    end
+  end
 end