mongoid 6.4.4 → 7.3.2

data/spec/mongoid/attributes/projector_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Attributes::Projector do
+  Dir[File.join(File.dirname(__FILE__), 'projector_data', '*.yml')].sort.each do |path|
+    context File.basename(path) do
+      specs = YAML.load(File.read(path))
+
+      specs.each do |spec|
+        context spec['name'] do
+
+          if spec['pending']
+            pending spec['pending'].to_s
+          end
+
+          let(:projection) do
+            spec['projection']
+          end
+
+          let(:projector) do
+            Mongoid::Attributes::Projector.new(projection)
+          end
+
+          spec.fetch('queries').each do |query_spec|
+            context query_spec.fetch('query').inspect do
+              let(:query) { query_spec['query'] }
+
+              context 'attribute_or_path_allowed?' do
+                it "is #{query_spec.fetch('allowed')}" do
+                  projector.attribute_or_path_allowed?(query).should be query_spec['allowed']
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/attributes/readonly_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Attributes::Readonly do
@@ -96,30 +99,14 @@ describe Mongoid::Attributes::Readonly do
       context "when updating via the setter" do
 
         it "does not update the first field" do
-          expect {
-            person.title = 'mr'
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.title).to eq("sir")
-        end
-
-        it "does not update the second field" do
-          expect {
-            person.aliased_timestamp = Time.at(43)
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.aliased_timestamp).to eq(Time.at(42))
-        end
-
-        it "does not persist the first field" do
-          expect {
-            person.title = 'mr'
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+          person.title = 'mr'
+          person.save
           expect(person.reload.title).to eq("sir")
         end
 
-        it "does not persist the second field" do
-          expect {
-            person.aliased_timestamp = Time.at(43)
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        it "does not update the second field" do
+          person.aliased_timestamp = Time.at(43)
+          person.save
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
@@ -128,19 +115,20 @@ describe Mongoid::Attributes::Readonly do
 
         context 'with single field operation' do
 
-          it "raises an error " do
-            expect {
-              person.inc(score: 1)
-            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          it "updates the field" do
+            person.inc(score: 1)
+            person.save
+            expect(person.reload.score).to eq(2)
           end
         end
 
         context 'with multiple fields operation' do
 
-          it "raises an error " do
-            expect {
-              person.inc(score: 1, age: 1)
-            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          it "updates the fields" do
+            person.inc(score: 1, age: 1)
+            person.save
+            expect(person.reload.score).to eq(2)
+            expect(person.reload.age).to eq(101)
           end
         end
       end
@@ -149,21 +137,20 @@ describe Mongoid::Attributes::Readonly do
 
         context 'with single field operation' do
 
-          it "raises an error " do
-            expect {
-              person.bit(score: { or: 13 })
-            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          it "does the update" do
+            person.bit(score: { or: 13 })
+            person.save
+            expect(person.reload.score).to eq(13)
           end
         end
 
         context 'with multiple fields operation' do
 
-          it "raises an error " do
-            expect {
-              person.bit(
-                age: { and: 13 }, score: { or: 13 }, inte: { and: 13, or: 10 }
-              )
-            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          it "udpates the attribute" do
+            person.bit(age: {and: 13}, score: {or: 13})
+            person.save
+            expect(person.reload.score).to eq(13)
+            expect(person.reload.age).to eq(4)
           end
         end
       end
@@ -171,30 +158,14 @@ describe Mongoid::Attributes::Readonly do
       context "when updating via []=" do
 
         it "does not update the first field" do
-          expect {
-            person[:title] = "mr"
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.title).to eq("sir")
-        end
-
-        it "does not update the second field" do
-          expect {
-            person[:aliased_timestamp] = Time.at(43)
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.aliased_timestamp).to eq(Time.at(42))
-        end
-
-        it "does not persist the first field" do
-          expect {
-            person[:title] = "mr"
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+          person[:title] = "mr"
+          person.save
           expect(person.reload.title).to eq("sir")
         end
 
-        it "does not persist the second field" do
-          expect {
-            person[:aliased_timestamp] = Time.at(43)
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        it "does not update the second field" do
+          person[:aliased_timestamp] = Time.at(43)
+          person.save
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
@@ -202,30 +173,14 @@ describe Mongoid::Attributes::Readonly do
       context "when updating via write_attribute" do
 
         it "does not update the first field" do
-          expect {
-            person.write_attribute(:title, "mr")
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.title).to eq("sir")
-        end
-
-        it "does not update the second field" do
-          expect {
-            person.write_attribute(:aliased_timestamp, Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.aliased_timestamp).to eq(Time.at(42))
-        end
-
-        it "does not persist the first field" do
-          expect {
-            person.write_attribute(:title, "mr")
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+          person.write_attribute(:title, "mr")
+          person.save
           expect(person.reload.title).to eq("sir")
         end
 
-        it "does not persist the second field" do
-          expect {
-            person.write_attribute(:aliased_timestamp, Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        it "does not update the second field" do
+          person.write_attribute(:aliased_timestamp, Time.at(43))
+          person.save
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
@@ -233,30 +188,14 @@ describe Mongoid::Attributes::Readonly do
       context "when updating via update_attributes" do
 
         it "does not update the first field" do
-          expect {
-            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.title).to eq("sir")
-        end
-
-        it "does not update the second field" do
-          expect {
-            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.aliased_timestamp).to eq(Time.at(42))
-        end
-
-        it "does not persist the first field" do
-          expect {
-            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+          person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
+          person.save
           expect(person.reload.title).to eq("sir")
         end
 
-        it "does not persist the second field" do
-          expect {
-            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        it "does not update the second field" do
+          person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
+          person.save
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
@@ -264,30 +203,14 @@ describe Mongoid::Attributes::Readonly do
       context "when updating via update_attributes!" do
 
         it "does not update the first field" do
-          expect {
-            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.title).to eq("sir")
-        end
-
-        it "does not update the second field" do
-          expect {
-            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
-          expect(person.aliased_timestamp).to eq(Time.at(42))
-        end
-
-        it "does not persist the first field" do
-          expect {
-            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+          person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
+          person.save
           expect(person.reload.title).to eq("sir")
         end
 
-        it "does not persist the second field" do
-          expect {
-            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
-          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        it "does not update the second field" do
+          person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
+          person.save
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
@@ -297,7 +220,7 @@ describe Mongoid::Attributes::Readonly do
         it "raises an error" do
           expect {
             person.update_attribute(:title, "mr")
-          }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
         end
       end
 
@@ -306,9 +229,44 @@ describe Mongoid::Attributes::Readonly do
         it "raises an error" do
           expect {
             person.remove_attribute(:title)
-          }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
         end
       end
     end
+
+    context 'when a foreign_key is defined as readonly' do
+
+      let(:attributes) do
+        :mother_id
+      end
+
+      context 'when the relation exists' do
+
+        let(:mother) do
+          Person.create
+        end
+
+        let(:child) do
+          Person.create(mother: mother)
+          Person.find_by(mother: mother)
+        end
+
+        it 'the relation can still be accessed' do
+          expect(child.mother).to eq(mother)
+        end
+      end
+
+      context 'when the relation does not exist' do
+
+        let(:child) do
+          Person.create
+        end
+
+        it 'the relation is nil' do
+          expect(child.mother).to be_nil
+        end
+      end
+
+    end
   end
 end

data/spec/mongoid/attributes_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Attributes do
@@ -42,7 +45,7 @@ describe Mongoid::Attributes do
             context "accessing via []" do
 
               it "does not raise an error" do
-                expect(from_db["desc"]).to eq("en" => "test")
+                expect(from_db["desc"]).to eq("test")
               end
             end
 
@@ -93,6 +96,49 @@ describe Mongoid::Attributes do
             it "does not raise an error" do
               expect(from_db.map).to eq(map)
             end
+
+            context 'when only one of the hash fields is projected' do
+
+              let(:map) do
+                { 'dates' => { 'y' => { '2016' => 'Berlin', '2017' => 'Munich' } } }
+              end
+
+              let(:expected) do
+                { 'dates' => { 'y' => {
+                  '2016' => 'Berlin',
+                } } }
+              end
+
+              it 'retrieves only the projected fields' do
+                expect(from_db.map).to eq(expected)
+              end
+            end
+
+            context 'when several of the hash fields is projected' do
+
+              let(:map) do
+                { 'dates' => { 'y' => {
+                  '2016' => 'Berlin',
+                  '2017' => 'Munich',
+                  '2018' => 'Krakow',
+                } } }
+              end
+
+              let(:expected) do
+                { 'dates' => { 'y' => {
+                  '2016' => 'Berlin',
+                  '2018' => 'Krakow',
+                } } }
+              end
+
+              let(:from_db) do
+                Person.only('map.dates.y.2016', 'map.dates.y.2018').first
+              end
+
+              it 'retrieves only the projected fields' do
+                expect(from_db.map).to eq(expected)
+              end
+            end
           end
         end
 
@@ -150,6 +196,17 @@ describe Mongoid::Attributes do
 
   describe "#[]" do
 
+    context 'when the document has a custom attribute type' do
+
+      let(:bar) do
+        Bar.create(lat_lng: LatLng.new(52.30, 13.25))
+      end
+
+      it 'returns the demongoized version of the attribute' do
+        expect(bar.reload[:lat_lng]).to be_a(LatLng)
+      end
+    end
+
     context "when the document is a new record" do
 
       let(:person) do
@@ -165,7 +222,7 @@ describe Mongoid::Attributes do
         context "when passing just the name" do
 
           it "returns the full value" do
-            expect(person[:desc]).to eq("en" => "testing")
+            expect(person[:desc]).to eq("testing")
           end
         end
 
@@ -231,6 +288,91 @@ 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
+              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
+              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
+              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
@@ -268,6 +410,20 @@ describe Mongoid::Attributes do
 
   describe "#[]=" do
 
+    context 'when the document has a custom attribute type' do
+
+      let(:bar) do
+        Bar.new.tap do |b|
+          b[:lat_lng] = LatLng.new(52.30, 13.25)
+          b.save
+        end
+      end
+
+      it 'sets the demongoized version of the attribute' do
+        expect(bar.reload.lat_lng).to be_a(LatLng)
+      end
+    end
+
     let(:person) do
       Person.new
     end
@@ -301,6 +457,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
@@ -768,6 +985,17 @@ describe Mongoid::Attributes do
 
   describe "#read_attribute" do
 
+    context 'when the document has a custom attribute type' do
+
+      let(:bar) do
+        Bar.create(lat_lng: LatLng.new(52.30, 13.25))
+      end
+
+      it 'returns the demongoized version of the attribute' do
+        expect(bar.reload.read_attribute(:lat_lng)).to be_a(LatLng)
+      end
+    end
+
     context "when the document is a new record" do
 
       let(:person) do
@@ -854,6 +1082,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
@@ -1310,10 +1582,16 @@ describe Mongoid::Attributes do
     context "when attribute is a Hash" do
       let(:person) { Person.new map: { somekey: "somevalue" } }
 
-      it "raises an error when try to set an invalid value" do
-        expect {
+      it "raises an error when trying to set a value of invalid type - array" do
+        expect do
           person.map = []
-        }.to raise_error(Mongoid::Errors::InvalidValue)
+        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type Array cannot be written to a field of type Hash/)
+      end
+
+      it "raises an error when trying to set a value of invalid type - boolean" do
+        expect do
+          person.map = false
+        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type FalseClass cannot be written to a field of type Hash/)
       end
 
       it "can set a Hash value" do
@@ -1328,10 +1606,16 @@ describe Mongoid::Attributes do
         expect(person.aliases).to eq([ :alias_1 ])
       end
 
-      it "raises an error when try to set an invalid value" do
-        expect {
+      it "raises an error when trying to set a value of invalid type - hash" do
+        expect do
           person.aliases = {}
-        }.to raise_error(Mongoid::Errors::InvalidValue)
+        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type Hash cannot be written to a field of type Array/)
+      end
+
+      it "raises an error when trying to set a value of invalid type - boolean" do
+        expect do
+          person.aliases = false
+        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type FalseClass cannot be written to a field of type Array/)
       end
     end
 
@@ -1347,6 +1631,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
@@ -1386,7 +1715,7 @@ describe Mongoid::Attributes do
   end
 
   describe "#typed_attributes"  do
-    
+
     let(:date_time) do
       DateTime.current
     end
@@ -1600,6 +1929,61 @@ describe Mongoid::Attributes do
     end
   end
 
+  describe '#unalias_attribute' do
+    let(:shirt) { Shirt.new }
+    let(:id) { '1234' }
+
+    context 'when creating object' do
+      let(:shirt) { Shirt.new(id: id) }
+
+      it 'id and _id are not the same' do
+        expect(shirt.id).to eq(id)
+        expect(shirt._id).not_to eq(id)
+      end
+    end
+
+    context 'update' do
+      before do
+        shirt.update(id: id)
+      end
+
+      it 'updates id but not_id' do
+        expect(shirt.id).to eq(id)
+        expect(shirt._id).not_to eq(id)
+      end
+    end
+
+    context 'id=' do
+      before do
+        shirt.id = id
+      end
+
+      it 'sets id and not _id' do
+        expect(shirt.id).to eq(id)
+        expect(shirt._id).not_to eq(id)
+      end
+    end
+
+    context 'id?' do
+      context 'with null id' do
+        it 'returns false' do
+          expect(shirt.id?).to be false
+          expect(shirt._id?).to be true
+        end
+      end
+
+      context 'with id' do
+        before do
+          shirt.id = id
+        end
+
+        it 'returns true' do
+          expect(shirt.id?).to be true
+        end
+      end
+    end
+  end
+
   describe "#alias_attribute" do
 
     let(:product) do