mongoid 6.4.4 → 7.3.2

data/spec/mongoid/attributes/dynamic_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Attributes::Dynamic do
+  shared_examples_for 'dynamic field' do
+    let(:raw_attributes) do
+      {attr_name => 'foo bar'}
+    end
+
+    context 'when reading attributes' do
+      context 'an unsaved model' do
+        it 'can be read' do
+          bar = Bar.new(raw_attributes)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+
+      context 'saved model' do
+        it 'can be read' do
+          bar = Bar.new(raw_attributes)
+          bar.save!
+
+          bar = Bar.find(bar.id)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+
+      context 'when attribute is not set' do
+        it 'cannot be read' do
+          bar = Bar.new
+          expect do
+            bar.send(attr_name)
+          end.to raise_error(NoMethodError)
+        end
+
+        context 'reading via read_attribute' do
+          it 'returns nil' do
+            bar = Bar.new
+            expect(bar.read_attribute(:foo)).to be nil
+          end
+        end
+
+        context 'reading via []' do
+          it 'returns nil' do
+            bar = Bar.new
+            expect(bar[:foo]).to be nil
+          end
+        end
+      end
+    end
+
+    context 'when writing attributes via constructor' do
+      it 'can be written' do
+        bar = Bar.new(raw_attributes)
+        bar.save!
+
+        bar = Bar.find(bar.id)
+        expect(bar.send(attr_name)).to eq('foo bar')
+      end
+    end
+
+    context 'when writing attributes via attributes=' do
+      it 'can be written' do
+        bar = Bar.new
+        bar.attributes = raw_attributes
+        bar.save!
+
+        bar = Bar.find(bar.id)
+        expect(bar.send(attr_name)).to eq('foo bar')
+      end
+    end
+
+    context 'when writing attributes via write_attribute' do
+      it 'can be written' do
+        bar = Bar.new
+        bar.write_attribute(attr_name, 'foo bar')
+        bar.save!
+
+        bar = Bar.find(bar.id)
+        expect(bar.send(attr_name)).to eq('foo bar')
+      end
+    end
+
+    context 'when writing attributes via []=' do
+      context 'string key' do
+        it 'can be written' do
+          bar = Bar.new
+          bar[attr_name.to_s] = 'foo bar'
+          bar.save!
+
+          bar = Bar.find(bar.id)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+
+      context 'symbol key' do
+        it 'can be written' do
+          bar = Bar.new
+          bar[attr_name.to_sym] = 'foo bar'
+          bar.save!
+
+          bar = Bar.find(bar.id)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+    end
+
+    context 'when writing attributes via #{attribute}=' do
+      context 'when attribute is not already set' do
+        let(:bar) { Bar.new }
+
+        it 'cannot be written' do
+          expect do
+            bar.send("#{attr_name}=", 'foo bar')
+            bar.save!
+          end.to raise_error(NoMethodError)
+        end
+      end
+
+      context 'when attribute is already set' do
+        let(:bar) { Bar.new(attr_name => 'foo bar') }
+
+        it 'can be written' do
+          bar.send("#{attr_name}=", 'new foo bar')
+          bar.save!
+
+          _bar = Bar.find(bar.id)
+          expect(_bar.send(attr_name)).to eq('new foo bar')
+        end
+      end
+    end
+  end
+
+  context 'when attribute name is alphanumeric' do
+    let(:attr_name) { 'foo' }
+
+    it_behaves_like 'dynamic field'
+  end
+
+  context 'when attribute name contains spaces' do
+    let(:attr_name) { 'hello world' }
+
+    it_behaves_like 'dynamic field'
+  end
+
+  context 'when attribute name contains special characters' do
+    let(:attr_name) { 'hello%world' }
+
+    it_behaves_like 'dynamic field'
+  end
+end

data/spec/mongoid/attributes/nested_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Attributes::Nested do
@@ -12,10 +15,12 @@ describe Mongoid::Attributes::Nested do
 
       before do
         Person.accepts_nested_attributes_for :favorites
+        Person.accepts_nested_attributes_for :children
       end
 
       after do
         Person.send(:undef_method, :favorites_attributes=)
+        Person.send(:undef_method, :children_attributes=)
         Person.nested_attributes.clear
       end
 
@@ -23,9 +28,18 @@ describe Mongoid::Attributes::Nested do
         expect(person).to respond_to(:favorites_attributes=)
       end
 
+      it "does not autosave if the association is embedded" do
+        expect(person).not_to respond_to(:autosave_documents_for_favorites)
+      end
+
+      it "autosaves if the association is not embedded" do
+        expect(person).to respond_to(:autosave_documents_for_children)
+      end
+
       it "adds the method name to the nested attributes list" do
         expect(Person.nested_attributes).to eq({
-          "favorites_attributes" => "favorites_attributes="
+          "favorites_attributes" => "favorites_attributes=",
+          "children_attributes" => "children_attributes="
         })
       end
     end
@@ -41,12 +55,12 @@ describe Mongoid::Attributes::Nested do
         Account.nested_attributes.clear
       end
 
-      let(:metadata) do
+      let(:association) do
         Account.reflect_on_association(:alerts)
       end
 
       it "keeps autosave set to false" do
-        expect(metadata).to_not be_autosave
+        expect(association).to_not be_autosave
       end
     end
   end
@@ -202,11 +216,12 @@ describe Mongoid::Attributes::Nested do
     context "when the relation is a referenced in" do
 
       before do
-        Post.accepts_nested_attributes_for :person
+        Post.accepts_nested_attributes_for :person, autosave: false
       end
 
       after do
-        Post.reset_callbacks(:save)
+        Post.send(:undef_method, :person_attributes=)
+        Post.nested_attributes.clear
       end
 
       let(:post) do
@@ -219,7 +234,7 @@ describe Mongoid::Attributes::Nested do
     end
   end
 
-  describe "##{name}_attributes=" do
+  describe "*_attributes=" do
 
     context "when the parent document is new" do
 
@@ -4381,12 +4396,11 @@ describe Mongoid::Attributes::Nested do
 
     context "when nesting multiple levels and parent is timestamped" do
 
-      before do
-        class Address
-          after_save do
-            addressable.touch
-          end
-        end
+      around do |example|
+        original_relations = Location.relations
+        Location.embedded_in :address, touch: true
+        example.run
+        Location.relations = original_relations
       end
 
       after do
@@ -4766,6 +4780,13 @@ describe Mongoid::Attributes::Nested do
           user.update_attributes(params)
         end
 
+        around do |example|
+          original_relations = User.relations
+          User.has_many :posts, foreign_key: :author_id, validate: false, autosave: true
+          example.run
+          user.relations = original_relations
+        end
+
         let(:post) do
           user.posts.first
         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