mongoid 7.1.6 → 7.1.10

data/spec/mongoid/attributes_spec.rb

@@ -245,6 +245,97 @@ describe Mongoid::Attributes do
         end
       end
 
+      context "when the field was not explicitly defined" do
+
+        context "when excluding with only and the field was not excluded" do
+
+          let(:from_db) do
+            Person.only(:_id).first
+          end
+
+          it "raises an error" do
+            expect {
+              from_db[:undefined_field]
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
+
+        context "when excluding with without and the field was excluded" do
+
+          let(:from_db) do
+            Person.without(:title).first
+          end
+
+          it "raises an error" do
+            expect {
+              from_db[:title]
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
+
+        context "when excluding with without and the field was not excluded" do
+
+          let(:from_db) do
+            Person.without(:title).first
+          end
+
+          it "returns nil" do
+            from_db[:undefined_field].should be nil
+          end
+        end
+      end
+
+      context 'when projecting with #only' do
+        let!(:person) do
+          Person.create(title: 'sir', name: { first_name: 'Jose', language: { name: 'es' } })
+        end
+
+        context 'when projecting an embedded association' do
+          let(:from_db) do
+            Person.only(:name).first
+          end
+
+          context 'when retrieving a field of the association using the dot notation' do
+
+            it 'retrieves the field' do
+              pending 'MONGOID-5032, fixed in 7.3'
+
+              expect(from_db['name.first_name']).to eq 'Jose'
+            end
+          end
+
+          context 'when retrieving a field of a nested association using the dot notation' do
+            it 'retrieves the field' do
+              pending 'MONGOID-5032, fixed in 7.3'
+
+              expect(from_db['name.language.name']).to eq 'es'
+            end
+          end
+        end
+
+        context 'when projecting a sub-association of an embedded association' do
+          let(:from_db) do
+            Person.only('name.language').first
+          end
+
+          context 'when retrieving a field under the projected sub-association' do
+            it 'retrieves the field' do
+              pending 'MONGOID-5032, fixed in 7.3'
+
+              expect(from_db['name.language.name']).to eq 'es'
+            end
+          end
+
+          context 'when retrieving a non-projected field' do
+            it 'raises MissingAttributeError' do
+              expect do
+                from_db['name.first_name']
+              end.to raise_error(ActiveModel::MissingAttributeError)
+            end
+          end
+        end
+      end
+
       context "when the attribute does not exist" do
 
         before do
@@ -329,6 +420,67 @@ describe Mongoid::Attributes do
         expect(terms).to eq(true)
       end
     end
+
+    context 'when the field is not explicitly defined' do
+      let(:bar) { Bar.new }
+
+      before do
+        bar['missing_field'] = 42
+      end
+
+      it 'writes the value into attributes' do
+        bar.attributes.should == {'_id' => bar.id, 'missing_field' => 42}
+      end
+
+      it 'makes the attribute accessible via []' do
+        bar['missing_field'].should == 42
+      end
+
+      context 'when writing fields on a document with projection' do
+
+        let!(:person) do
+          Person.create(title: "sir")
+        end
+
+        context "when excluding with only and the field was not excluded" do
+
+          let(:from_db) do
+            Person.only(:_id).first
+          end
+
+          it "raises an error" do
+            expect {
+              from_db[:undefined_field] = 'x'
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
+
+        context "when excluding with without and the field was excluded" do
+
+          let(:from_db) do
+            Person.without(:title).first
+          end
+
+          it "raises an error" do
+            expect {
+              from_db[:title] = 'x'
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
+
+        context "when excluding with without and the field was not excluded" do
+
+          let(:from_db) do
+            Person.without(:title).first
+          end
+
+          it "writes the value" do
+            from_db[:undefined_field] = 'x'
+            from_db[:undefined_field].should == 'x'
+          end
+        end
+      end
+    end
   end
 
   describe "#_id" do
@@ -893,6 +1045,50 @@ describe Mongoid::Attributes do
         expect(person.age_before_type_cast).to eq("old")
       end
     end
+
+    context 'when reading fields on a document with projection' do
+
+      let!(:person) do
+        Person.create(title: "sir")
+      end
+
+      context "when excluding with only and the field was not excluded" do
+
+        let(:from_db) do
+          Person.only(:_id).first
+        end
+
+        it "raises an error" do
+          expect {
+            from_db.read_attribute(:undefined_field)
+          }.to raise_error(ActiveModel::MissingAttributeError)
+        end
+      end
+
+      context "when excluding with without and the field was excluded" do
+
+        let(:from_db) do
+          Person.without(:title).first
+        end
+
+        it "raises an error" do
+          expect {
+            from_db.read_attribute(:title)
+          }.to raise_error(ActiveModel::MissingAttributeError)
+        end
+      end
+
+      context "when excluding with without and the field was not excluded" do
+
+        let(:from_db) do
+          Person.without(:title).first
+        end
+
+        it "returns nil" do
+          from_db.read_attribute(:undefined_field).should be nil
+        end
+      end
+    end
   end
 
   describe "#attribute_present?" do
@@ -1398,6 +1594,51 @@ describe Mongoid::Attributes do
         expect(dictionary.description).to eq('foo')
       end
     end
+
+    context 'when writing fields on a document with projection' do
+
+      let!(:person) do
+        Person.create(title: "sir")
+      end
+
+      context "when excluding with only and the field was not excluded" do
+
+        let(:from_db) do
+          Person.only(:_id).first
+        end
+
+        it "raises an error" do
+          expect {
+            from_db.write_attribute(:undefined_field, 'x')
+          }.to raise_error(ActiveModel::MissingAttributeError)
+        end
+      end
+
+      context "when excluding with without and the field was excluded" do
+
+        let(:from_db) do
+          Person.without(:title).first
+        end
+
+        it "raises an error" do
+          expect {
+            from_db.write_attribute(:title, 'x')
+          }.to raise_error(ActiveModel::MissingAttributeError)
+        end
+      end
+
+      context "when excluding with without and the field was not excluded" do
+
+        let(:from_db) do
+          Person.without(:title).first
+        end
+
+        it "writes the value" do
+          from_db.write_attribute(:undefined_field, 'x')
+          from_db.read_attribute(:undefined_field).should == 'x'
+        end
+      end
+    end
   end
 
   describe "#typed_value_for" do

data/spec/mongoid/clients/options_spec.rb

@@ -141,6 +141,8 @@ describe Mongoid::Clients::Options, retry: 3 do
           end
 
           it 'does not disconnect the original cluster' do
+            skip 'https://jira.mongodb.org/browse/MONGOID-5130'
+
             expect(connections_after).to eq(connections_before)
             expect(cluster_before).to be(cluster_after)
           end

data/spec/mongoid/contextual/atomic_spec.rb

@@ -753,12 +753,25 @@ describe Mongoid::Contextual::Atomic do
       context.set(name: "Recoil")
     end
 
-    it "sets existing fields" do
-      expect(depeche_mode.reload.name).to eq("Recoil")
+    shared_examples 'writes as expected' do
+      it "sets existing fields" do
+        expect(depeche_mode.reload.name).to eq("Recoil")
+      end
+
+      it "sets non existent fields" do
+        expect(smiths.reload.name).to eq("Recoil")
+      end
     end
 
-    it "sets non existent fields" do
-      expect(smiths.reload.name).to eq("Recoil")
+    include_examples 'writes as expected'
+
+    context 'when fields being set have been projected out' do
+
+      let(:criteria) do
+        Band.only(:genres)
+      end
+
+      include_examples 'writes as expected'
     end
   end
 

data/spec/mongoid/criteria/queryable/selectable_logical_spec.rb

@@ -1447,6 +1447,42 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+
+    context 'when using multiple criteria and symbol operators' do
+      context 'when using fields that meaningfully evolve values' do
+
+        let(:query) do
+          Dictionary.any_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$or' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in local time,
+            # because we are querying on a Time field and dates are interpreted
+            # in local time when assigning to Time fields
+            {'published' => {'$gt' => Time.local(2020, 2, 3)}},
+          ]}
+        end
+      end
+
+      context 'when using fields that do not meaningfully evolve values' do
+
+        let(:query) do
+          Dictionary.any_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$or' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in UTC,
+            # because we are querying on a Date field and dates are interpreted
+            # in UTC when persisted as dates by Mongoid
+            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
+          ]}
+        end
+      end
+    end
   end
 
   describe "#not" do

data/spec/mongoid/criteria_spec.rb

@@ -3645,10 +3645,14 @@ describe Mongoid::Criteria do
 
       before do
         expect(Person).to receive(:minor).and_call_original
+        expect(Person).to receive(:older_than).and_call_original
       end
 
       it "calls the method on the class" do
         expect(criteria.minor).to be_empty
+        expect do
+          criteria.older_than(age: 25)
+        end.not_to raise_error
       end
     end
 

data/spec/mongoid/document_query_spec.rb

@@ -36,4 +36,55 @@ describe Mongoid::Document do
       expect(_person.age).to be 42
     end
   end
+
+  context 'when projecting with #without' do
+    before do
+      duck = Pet.new(name: 'Duck')
+      Person.create!(username: 'Dev', title: 'CEO', pet: duck)
+    end
+
+    let(:person) { Person.where(username: 'Dev').without(:title).first }
+
+      it 'allows access to attribute of embedded document' do
+      expect(person.pet.name).to eq 'Duck'
+    end
+
+    context 'when exclusion starts with association name but is not the association' do
+
+      let(:person) { Person.where(username: 'Dev').without(:pet_).first }
+
+      it 'allows access to attribute of embedded document' do
+        expect(person.pet.name).to eq 'Duck'
+      end
+    end
+
+    context 'when exclusion starts with prefix of association name' do
+
+      let(:person) { Person.where(username: 'Dev').without(:pe).first }
+
+      it 'allows access to attribute of embedded document' do
+        expect(person.pet.name).to eq 'Duck'
+      end
+    end
+
+    context 'when another attribute of the association is excluded' do
+
+      let(:person) { Person.where(username: 'Dev').without('pet.weight').first }
+
+      it 'allows access to non-excluded attribute of embedded document' do
+        expect(person.pet.name).to eq 'Duck'
+      end
+    end
+
+    context 'when the excluded attribute of the association is retrieved' do
+
+      let(:person) { Person.where(username: 'Dev').without('pet.name').first }
+
+      it 'prohibits the retrieval' do
+        lambda do
+          person.pet.name
+        end.should raise_error(ActiveModel::MissingAttributeError)
+      end
+    end
+  end
 end

data/spec/mongoid/errors/mongoid_error_spec.rb

@@ -10,14 +10,26 @@ describe Mongoid::Errors::MongoidError do
   let(:options) { {} }
 
   before do
-    {"message_title" => "message", "summary_title" => "summary", "resolution_title" => "resolution"}.each do |key, name|
-      expect(::I18n).to receive(:translate).with("mongoid.errors.messages.#{key}", {}).and_return(name)
-    end
-
-    ["message", "summary", "resolution"].each do |name|
-      expect(::I18n).to receive(:translate).
-        with("mongoid.errors.messages.#{key}.#{name}", {}).
-      and_return(name)
+    if RUBY_VERSION.start_with?('3.', '2.7')
+      {"message_title" => "message", "summary_title" => "summary", "resolution_title" => "resolution"}.each do |key, name|
+        expect(::I18n).to receive(:translate).with("mongoid.errors.messages.#{key}", **{}).and_return(name)
+      end
+
+      ["message", "summary", "resolution"].each do |name|
+        expect(::I18n).to receive(:translate).
+          with("mongoid.errors.messages.#{key}.#{name}", **{}).
+          and_return(name)
+      end
+    else
+      {"message_title" => "message", "summary_title" => "summary", "resolution_title" => "resolution"}.each do |key, name|
+        expect(::I18n).to receive(:translate).with("mongoid.errors.messages.#{key}", {}).and_return(name)
+      end
+
+      ["message", "summary", "resolution"].each do |name|
+        expect(::I18n).to receive(:translate).
+          with("mongoid.errors.messages.#{key}.#{name}", {}).
+          and_return(name)
+      end
     end
 
     error.compose_message(key, options)