mongoid 7.2.6 → 7.3.3

data/spec/mongoid/association/referenced/has_many/proxy_spec.rb

@@ -1568,12 +1568,12 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       end
 
       context 'when association is not loaded' do
-        it 'queries database on each call' do
-          expect_query(1) do
-            movie.ratings.any?.should be true
-          end
+        before do
+          movie.ratings._loaded?.should be false
+        end
 
-          expect_query(1) do
+        it 'does not query the database because it knows about the added models' do
+          expect_no_queries do
             movie.ratings.any?.should be true
           end
         end
@@ -1581,7 +1581,7 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
 
       context 'when association is loaded' do
         it 'does not query database' do
-          expect_query(1) do
+          expect_no_queries do
             movie.ratings.any?.should be true
           end
 

data/spec/mongoid/association/referenced/has_one_models.rb

@@ -19,6 +19,14 @@ class HomAccreditation
 
   field :degree, type: String
   field :year, type: Integer, default: 2012
+
+  def format
+    'fmt'
+  end
+
+  def price
+    42
+  end
 end
 
 class HomAccreditation::Child

data/spec/mongoid/atomic/paths_spec.rb

@@ -113,10 +113,33 @@ describe Mongoid::Atomic::Paths do
         person.addresses << address
       end
 
-      it "returns the association with id.atomic_selector" do
-        expect(address.atomic_selector).to eq(
-          { "_id" => person.id, "addresses._id" => address.id }
-        )
+      context 'when the parent is persisted' do
+
+        let(:person) do
+          Person.create!
+        end
+
+        before do
+          person.should be_persisted
+        end
+
+        it "returns the association with id.atomic_selector" do
+          expect(address.atomic_selector).to eq(
+            { "_id" => person.id, "addresses._id" => address.id }
+          )
+        end
+      end
+
+      context 'when the parent is not persisted' do
+        before do
+          person.should be_new_record
+        end
+
+        it "returns the association with id.atomic_selector" do
+          expect(address.atomic_selector).to eq(
+            { "_id" => person.id, "addresses._id" => address.id }
+          )
+        end
       end
     end
 
@@ -127,14 +150,43 @@ describe Mongoid::Atomic::Paths do
         person.addresses << address
       end
 
-      it "returns the JSON notation to the document with ids" do
-        expect(location.atomic_selector).to eq(
-          {
-            "_id" => person.id,
-            "addresses._id" => address.id,
-            "addresses.locations._id" => location.id
-          }
-        )
+      context 'when the parent is persisted' do
+
+        let(:person) do
+          Person.create!
+        end
+
+        before do
+          person.should be_persisted
+        end
+
+        it "returns the JSON notation to the document with ids" do
+          expect(location.atomic_selector).to eq(
+            {
+              "_id" => person.id,
+              "addresses._id" => address.id,
+              "addresses.0.locations._id" => location.id
+            }
+          )
+        end
+      end
+
+      context 'when the parent is not persisted' do
+        before do
+          person.should be_new_record
+        end
+
+        it "returns the JSON notation to the document with ids" do
+          expect(location.atomic_selector).to eq(
+            {
+              "_id" => person.id,
+              "addresses._id" => address.id,
+              # This condition is technically acceptable for finds
+              # but probably won't work for modifications of 'locations'.
+              "addresses.locations._id" => location.id
+            }
+          )
+        end
       end
     end
   end

data/spec/mongoid/attributes/projector_data/embedded.yml

@@ -0,0 +1,105 @@
+- name: embedded field - inclusion
+  projection:
+    foo.bar: 1
+  
+  queries: &embedded-field-inclusion-expectations
+    # Top-level field is allowed as a container
+    - query: foo
+      allowed: true
+      
+    # Unmentioned field is not allowed
+    - query: bar
+      allowed: false
+      
+    # A peer to the field isn't allowed
+    - query: foo.buck
+      allowed: false
+      
+    # A more nested field is allowed
+    - query: foo.bar.baz
+      allowed: true
+
+- name: embedded field - exclusion
+  projection:
+    foo.bar: 0
+  
+  queries: &embedded-field-exclusion-expectations
+    # Top-level field is allowed
+    - query: foo
+      allowed: true
+    
+    # Unmentioned field is allowed
+    - query: bar
+      allowed: true
+      
+    # A peer to the excluded field is allowed
+    - query: foo.buck
+      allowed: true
+      
+    # A more nested field is not allowed
+    - query: foo.bar.baz
+      allowed: false
+
+- name: parent and child fields - inclusion
+  projection:
+    foo.bar: 1
+    foo.bar.baz: 1
+  
+  queries:
+    # Top-level field is allowed
+    - query: foo
+      allowed: true
+      
+    # Second-level field is allowed
+    - query: foo.bar
+      allowed: true
+    
+    # Third-level field is also allowed
+    - query: foo.bar.baz
+      allowed: true
+    
+    # Fourth-level field is still allowed
+    - query: foo.bar.baz.zzz
+      allowed: true
+    
+    # Unmentioned siblings are not allowed
+    - query: buck
+      allowed: false
+    - query: foo.buck
+      allowed: false
+    
+    # This sibling is under the second-level include and is allowed
+    - query: foo.bar.buck
+      allowed: true
+
+- name: parent and child fields - exclusion
+  projection:
+    foo.bar: 0
+    foo.bar.baz: 0
+  
+  queries:
+    # Top-level field is allowed
+    - query: foo
+      allowed: true
+      
+    # Second-level field is not allowed
+    - query: foo.bar
+      allowed: false
+    
+    # Third-level field is also not allowed
+    - query: foo.bar.baz
+      allowed: false
+    
+    # Fourth-level field is still not allowed
+    - query: foo.bar.baz.zzz
+      allowed: false
+    
+    # Unmentioned siblings are allowed
+    - query: buck
+      allowed: true
+    - query: foo.buck
+      allowed: true
+      
+    # This sibling is under the second-level exclude and is disallowed
+    - query: foo.bar.buck
+      allowed: false

data/spec/mongoid/attributes/projector_data/fields.yml

@@ -0,0 +1,93 @@
+- name: simple inclusion - integer
+  projection:
+    foo: 1
+  
+  queries: &field-inclusion-expectations
+    - query: foo
+      allowed: true
+    - query: bar
+      allowed: false
+
+- name: simple inclusion - boolean
+  projection:
+    foo: true
+  
+  queries: &field-inclusion-expectations
+    - query: foo
+      allowed: true
+    - query: bar
+      allowed: false
+
+- name: positive integer - inclusion
+  projection:
+    foo: 2
+  
+  queries: *field-inclusion-expectations
+
+- name: simple exclusion - integer
+  projection:
+    foo: 0
+  
+  queries: &field-exclusion-expectations
+    - query: foo
+      allowed: false
+    - query: bar
+      allowed: true
+
+- name: simple exclusion - boolean
+  projection:
+    foo: false
+  
+  queries: &field-exclusion-expectations
+    - query: foo
+      allowed: false
+    - query: bar
+      allowed: true
+
+- name: negative integer - exclusion
+  projection:
+    foo: -2
+  
+  queries: *field-exclusion-expectations
+
+- name: field inclusion with _id exclusion
+  projection:
+    foo: 1
+    _id: 0
+  
+  queries: &field-inclusion-with-id-exclusion-expectations
+    - query: foo
+      allowed: true
+      
+    - query: bar
+      allowed: false
+      
+    - query: _id
+      allowed: false
+
+- name: _id exclusion with field inclusion
+  projection:
+    _id: 0
+    foo: 1
+  
+  queries: *field-inclusion-with-id-exclusion-expectations
+
+- name: id inclusion
+  projection:
+    _id: 1
+  
+  queries:
+    - query: _id
+      allowed: true
+    - query: foo
+      allowed: false
+
+- name: id exclusion
+  projection:
+    _id: false
+  
+  queries:
+    - query: _id
+      allowed: false
+    - query: foo
+      allowed: true

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_spec.rb

@@ -96,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
 
@@ -298,16 +341,12 @@ describe Mongoid::Attributes do
           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
@@ -320,8 +359,6 @@ describe Mongoid::Attributes do
 
           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
@@ -1892,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