mongoid 8.1.12 → 9.0.0

data/spec/mongoid/extensions/date_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -6,8 +7,8 @@ describe Mongoid::Extensions::Date do
 
   describe "__mongoize_time__" do
 
-    context "when using active support's time zone" do
-      include_context 'using AS time zone'
+    context "when setting ActiveSupport time zone" do
+      include_context 'setting ActiveSupport time zone'
 
       let(:date) do
         Date.new(2010, 1, 1)
@@ -23,24 +24,6 @@ describe Mongoid::Extensions::Date do
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'
     end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
-
-      let(:date) do
-        Date.new(2010, 1, 1)
-      end
-
-      let(:expected_time) do
-        Time.local(2010, 1, 1, 0, 0, 0, 0)
-      end
-
-      let(:mongoized) do
-        date.__mongoize_time__
-      end
-
-      it_behaves_like 'mongoizes to Time'
-    end
   end
 
   describe ".demongoize" do

data/spec/mongoid/extensions/date_time_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -18,19 +19,12 @@ describe Mongoid::Extensions::DateTime do
 
     let(:expected_time) { date_time.to_time.in_time_zone }
 
-    context "when using active support's time zone" do
-      include_context 'using AS time zone'
+    context "when setting ActiveSupport time zone" do
+      include_context 'setting ActiveSupport time zone'
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'
       it_behaves_like 'maintains precision when mongoized'
     end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
-
-      it_behaves_like 'mongoizes to Time'
-      it_behaves_like 'maintains precision when mongoized'
-    end
   end
 
   describe ".demongoize" do

data/spec/mongoid/extensions/decimal128_spec.rb

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

data/spec/mongoid/extensions/false_class_spec.rb

@@ -1,16 +1,10 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
 describe Mongoid::Extensions::FalseClass do
 
-  describe "#__sortable__" do
-
-    it "returns 0" do
-      expect(false.__sortable__).to eq(0)
-    end
-  end
-
   describe "#is_a?" do
 
     context "when provided a Boolean" do

data/spec/mongoid/extensions/float_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -20,19 +21,12 @@ describe Mongoid::Extensions::Float do
 
     let(:expected_time) { Time.at(float).in_time_zone }
 
-    context "when using active support's time zone" do
-      include_context 'using AS time zone'
+    context "when setting ActiveSupport time zone" do
+      include_context 'setting ActiveSupport time zone'
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'
       it_behaves_like 'maintains precision when mongoized'
     end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
-
-      it_behaves_like 'mongoizes to Time'
-      it_behaves_like 'maintains precision when mongoized'
-    end
   end
 
   [ :mongoize, :demongoize ].each do |method|

data/spec/mongoid/extensions/hash_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -162,125 +163,6 @@ describe Mongoid::Extensions::Hash do
     end
   end
 
-  describe "#__consolidate__" do
-
-    context "when the hash already contains the key" do
-
-      context "when the $set is first" do
-
-        let(:hash) do
-          { "$set" => { name: "Tool" }, likes: 10, "$inc" => { plays: 1 }}
-        end
-
-        let(:consolidated) do
-          hash.__consolidate__(Band)
-        end
-
-        it "moves the non hash values under the provided key" do
-          expect(consolidated).to eq({
-            "$set" => { 'name' => "Tool", likes: 10 }, "$inc" => { 'plays' => 1 }
-          })
-        end
-      end
-
-      context "when the $set is not first" do
-
-        let(:hash) do
-          { likes: 10, "$inc" => { plays: 1 }, "$set" => { name: "Tool" }}
-        end
-
-        let(:consolidated) do
-          hash.__consolidate__(Band)
-        end
-
-        it "moves the non hash values under the provided key" do
-          expect(consolidated).to eq({
-            "$set" => { likes: 10, 'name' => "Tool" }, "$inc" => { 'plays' => 1 }
-          })
-        end
-      end
-    end
-
-    context "when the hash does not contain the key" do
-
-      let(:hash) do
-        { likes: 10, "$inc" => { plays: 1 }, name: "Tool"}
-      end
-
-      let(:consolidated) do
-        hash.__consolidate__(Band)
-      end
-
-      it "moves the non hash values under the provided key" do
-        expect(consolidated).to eq({
-          "$set" => { likes: 10, name: "Tool" }, "$inc" => { 'plays' => 1 }
-        })
-      end
-    end
-  end
-
-  context "when the hash key is a string" do
-
-    let(:hash) do
-      { "100" => { "name" => "hundred" } }
-    end
-
-    let(:nested) do
-      hash.__nested__("100.name")
-    end
-
-    it "should retrieve a nested value under the provided key" do
-      expect(nested).to eq "hundred"
-    end
-
-    context 'and the value is falsey' do
-      let(:hash) do
-        { "100" => { "name" => false } }
-      end
-      it "should retrieve the falsey nested value under the provided key" do
-        expect(nested).to eq false
-      end
-    end
-
-    context 'and the value is nil' do
-      let(:hash) do
-        { "100" => { 0 => "Please don't return this value!" } }
-      end
-      it "should retrieve the nil nested value under the provided key" do
-        expect(nested).to eq nil
-      end
-    end
-  end
-
-  context "when the hash key is an integer" do
-    let(:hash) do
-      { 100 => { "name" => "hundred" } }
-    end
-
-    let(:nested) do
-      hash.__nested__("100.name")
-    end
-
-    it "should retrieve a nested value under the provided key" do
-      expect(nested).to eq("hundred")
-    end
-  end
-
-  context "when the parent key is not present" do
-
-    let(:hash) do
-      { "101" => { "name" => "hundred and one" } }
-    end
-
-    let(:nested) do
-      hash.__nested__("100.name")
-    end
-
-    it "should return nil" do
-      expect(nested).to eq(nil)
-    end
-  end
-
   describe ".demongoize" do
 
     let(:hash) do
@@ -335,6 +217,10 @@ describe Mongoid::Extensions::Hash do
       it "converts the elements properly" do
         expect(mongoized[:date]).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
       end
+
+      it "mongoizes to a BSON::Document" do
+        expect(mongoized).to be_a(BSON::Document)
+      end
     end
 
     context "when object is nil" do
@@ -356,6 +242,20 @@ describe Mongoid::Extensions::Hash do
         expect(mongoized).to be_nil
       end
     end
+
+    describe "when mongoizing a BSON::Document" do
+      let(:mongoized) do
+        Hash.mongoize(BSON::Document.new({ x: 1, y: 2 }))
+      end
+
+      it "returns the same hash" do
+        expect(mongoized).to eq({ "x" => 1, "y" => 2 })
+      end
+
+      it "returns a BSON::Document" do
+        expect(mongoized).to be_a(BSON::Document)
+      end
+    end
   end
 
   describe "#mongoize" do
@@ -394,343 +294,4 @@ describe Mongoid::Extensions::Hash do
       expect(Hash).to be_resizable
     end
   end
-
-  shared_examples_for 'unsatisfiable criteria method' do
-
-    context "when the hash has only an empty _id criteria" do
-
-      let(:hash) do
-        { "_id" => { "$in" => [] }}
-      end
-
-      it "is true" do
-        expect(hash.send(meth)).to be true
-      end
-    end
-
-    context "when the hash has an empty _id criteria and another criteria" do
-
-      let(:hash) do
-        { "_id" => { "$in" => [] }, 'foo' => 'bar'}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }}]}
-      end
-
-      it "is true" do
-        expect(hash.send(meth)).to be true
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and and another criteria at top level" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }}], 'foo' => 'bar'}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and and another criteria in $and" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }}, {'foo' => 'bar'}]}
-      end
-
-      it "is true" do
-        expect(hash.send(meth)).to be true
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and and another criteria in $and value" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }, 'foo' => 'bar'}]}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $or" do
-
-      let(:hash) do
-        {'$or' => [{ "_id" => { "$in" => [] }}]}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $nor" do
-
-      let(:hash) do
-        {'$nor' => [{ "_id" => { "$in" => [] }}]}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-  end
-
-  describe "#blank_criteria?" do
-    let(:meth) { :blank_criteria? }
-
-    it_behaves_like 'unsatisfiable criteria method'
-  end
-
-  describe "#_mongoid_unsatisfiable_criteria?" do
-    let(:meth) { :_mongoid_unsatisfiable_criteria? }
-
-    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/integer_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -20,17 +21,11 @@ describe Mongoid::Extensions::Integer do
 
     let(:expected_time) { Time.at(integer).in_time_zone }
 
-    context "when using active support's time zone" do
-      include_context 'using AS time zone'
+    context "when setting ActiveSupport time zone" do
+      include_context 'setting ActiveSupport time zone'
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'
     end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
-
-      it_behaves_like 'mongoizes to Time'
-    end
   end
 
   [ :mongoize, :demongoize ].each do |method|

data/spec/mongoid/extensions/module_spec.rb

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

data/spec/mongoid/extensions/nil_class_spec.rb

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

data/spec/mongoid/extensions/object_id_spec.rb

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