mongoid 9.0.10 → 9.0.12

data/spec/mongoid/attributes/nested_spec.rb

@@ -8,11 +8,38 @@ require_relative '../association/referenced/has_and_belongs_to_many_models'
 require_relative './nested_spec_models'
 
 describe Mongoid::Attributes::Nested do
+  # Expects the enclosing context to define `build_with_id`, taking an id
+  # value and returning the document built with it in nested attributes.
+  shared_examples 'rejects non-scalar ids' do |klass_name|
+    not_found = /not found for class #{klass_name}/
+
+    context 'when the id is an operator hash' do
+      it 'raises a document not found error' do
+        expect { build_with_id({ '$ne' => nil }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
+      end
+    end
+
+    context 'when the id is an array' do
+      it 'raises a document not found error' do
+        expect { build_with_id([ BSON::ObjectId.new ]) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
+      end
+    end
+
+    context 'when the id is a malformed object id hash' do
+      it 'raises a document not found error' do
+        expect { build_with_id({ '$oid' => 'junk' }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
+      end
+    end
+  end
 
   describe ".accepts_nested_attributes_for" do
 
     context "when the autosave option is not defined" do
 
+
       let(:person) do
         Person.new
       end
@@ -164,24 +191,71 @@ describe Mongoid::Attributes::Nested do
       end
     end
 
-    context "when the relation is a references many" do
-
+    context 'when the relation is a has-many' do
       before do
         Person.send(:undef_method, :posts_attributes=)
         Person.accepts_nested_attributes_for :posts
       end
 
-      let(:person) do
-        Person.new(posts_attributes: { "1" => { title: "First" }})
+      context 'when adding a new document to a relation' do
+        let(:person) do
+          Person.new(posts_attributes: { '1' => { title: 'First' } })
+        end
+
+        it 'sets the nested attributes' do
+          expect(person.posts.first.title).to eq('First')
+        end
       end
 
-      it "sets the nested attributes" do
-        expect(person.posts.first.title).to eq("First")
+      context 'when adding an existing document to a relation' do
+        let(:person1) { Person.create! }
+        let(:post) { person1.posts.create!(title: 'Sample Post') }
+
+        let(:person2) { Person.create!(posts_attributes: { '0' => { id: post.id, title: 'Reparented!' } }) }
+
+        context 'when allow_reparenting_via_nested_attributes is false' do
+          config_override :allow_reparenting_via_nested_attributes, false
+
+          it 'raises a document not found error' do
+            expect { person2 }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context 'when allow_reparenting_via_nested_attributes is true' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          it 'sets the nested attributes' do
+            expect(person2.posts.map(&:title)).to eq([ 'Reparented!' ])
+          end
+        end
       end
-    end
 
-    context "when the relation is a references and referenced in many" do
+      context 'when the id in the attributes is not a scalar' do
+        let(:person) { Person.create! }
+
+        def build_with_id(id)
+          person.update!(posts_attributes: { '0' => { id: id, title: 'Crafted' } })
+        end
 
+        context 'when the association is empty' do
+          include_examples 'rejects non-scalar ids', 'Post'
+        end
+
+        context 'when the association is not empty' do
+          before { person.posts.create!(title: 'Existing') }
+
+          include_examples 'rejects non-scalar ids', 'Post'
+        end
+
+        context 'when allow_reparenting_via_nested_attributes is true' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          include_examples 'rejects non-scalar ids', 'Post'
+        end
+      end
+    end
+
+    context 'when the relation is a has-and-belongs-to-many' do
       before do
         Person.send(:undef_method, :preferences_attributes=)
         Person.accepts_nested_attributes_for :preferences
@@ -203,16 +277,100 @@ describe Mongoid::Attributes::Nested do
           )
         end
 
-        it "sets the nested attributes" do
-          expect(person.preferences.map(&:name)).to eq([preference.name])
+        context 'when allow_reparenting_via_nested_attributes is false' do
+          config_override :allow_reparenting_via_nested_attributes, false
+
+          it 'raises a document not found error' do
+            expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                             /Document\(s\) not found for class Preference/)
+          end
         end
 
-        it "updates attributes of existing document which is added to relation" do
-          preference_name = 'updated preference'
-          person = Person.new(
-            preferences_attributes: { 0 => { id: preference.id, name: preference_name } }
-          )
-          expect(person.preferences.map(&:name)).to eq([preference_name])
+        context 'when allow_reparenting_via_nested_attributes is true' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          it 'sets the nested attributes' do
+            expect(person.preferences.map(&:name)).to eq([ preference.name ])
+          end
+
+          it 'updates attributes of existing document which is added to relation' do
+            preference_name = 'updated preference'
+            person = Person.new(
+              preferences_attributes: { 0 => { id: preference.id, name: preference_name } }
+            )
+            expect(person.preferences.map(&:name)).to eq([ preference_name ])
+          end
+
+          context 'when the id does not correspond to an existing document' do
+            let(:person) do
+              Person.new(
+                preferences_attributes: { 0 => { id: BSON::ObjectId.new, name: 'Ghost' } }
+              )
+            end
+
+            context 'when raise_not_found_error is true' do
+              config_override :raise_not_found_error, true
+
+              it 'raises a document not found error' do
+                expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                                 /Document\(s\) not found for class Preference/)
+              end
+            end
+
+            context 'when raise_not_found_error is false' do
+              config_override :raise_not_found_error, false
+
+              it 'raises a document not found error' do
+                expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                                 /Document\(s\) not found for class Preference/)
+              end
+            end
+          end
+        end
+
+        context 'when _destroy is true for a document not in the relation' do
+          before do
+            Person.send(:undef_method, :preferences_attributes=)
+            Person.accepts_nested_attributes_for :preferences, allow_destroy: true
+          end
+
+          let(:person) do
+            Person.new(
+              preferences_attributes: { 0 => { id: preference.id, _destroy: '1' } }
+            )
+          end
+
+          it 'does not raise UnknownAttribute' do
+            expect { person }.not_to raise_error
+          end
+
+          it 'does not add the document to the relation' do
+            expect(person.preferences).to be_empty
+          end
+        end
+      end
+
+      context 'when the id in the attributes is not a scalar' do
+        let(:target) { Person.create! }
+
+        def build_with_id(id)
+          target.update!(preferences_attributes: { 0 => { id: id, name: 'Crafted' } })
+        end
+
+        context 'when the association is empty' do
+          include_examples 'rejects non-scalar ids', 'Preference'
+        end
+
+        context 'when the association is not empty' do
+          before { target.preferences.create!(name: 'Existing') }
+
+          include_examples 'rejects non-scalar ids', 'Preference'
+        end
+
+        context 'when allow_reparenting_via_nested_attributes is true' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          include_examples 'rejects non-scalar ids', 'Preference'
         end
       end
     end
@@ -1355,10 +1513,11 @@ describe Mongoid::Attributes::Nested do
             context "when the ids do not match" do
 
               it "raises an error" do
-                expect {
+                expect do
                   person.addresses_attributes =
-                    { "foo" => { "id" => "test", "street" => "Test" } }
-                }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Address with id\(s\)/)
+                    { 'foo' => { 'id' => 'test', 'street' => 'Test' } }
+                end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                   /Document\(s\) not found for class Address/)
               end
             end
           end
@@ -3012,12 +3171,12 @@ describe Mongoid::Attributes::Nested do
                 end
 
                 it "raises a document not found error" do
-                  expect {
+                  expect do
                     person.posts_attributes =
-                      { "0" =>
-                        { "id" => BSON::ObjectId.new.to_s, "title" => "Rogue" }
-                      }
-                  }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
+                      { '0' =>
+                        { 'id' => BSON::ObjectId.new.to_s, 'title' => 'Rogue' } }
+                  end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                     /Document not found for class Post/)
                 end
               end
             end
@@ -3048,10 +3207,11 @@ describe Mongoid::Attributes::Nested do
             context "when the ids do not match" do
 
               it "raises an error" do
-                expect {
+                expect do
                   person.posts_attributes =
-                    { "foo" => { "id" => "test", "title" => "Test" } }
-                }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
+                    { 'foo' => { 'id' => 'test', 'title' => 'Test' } }
+                end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                   /Document not found for class Post/)
               end
             end
           end
@@ -3765,10 +3925,11 @@ describe Mongoid::Attributes::Nested do
             context "when the ids do not match" do
 
               it "raises an error" do
-                expect {
+                expect do
                   person.preferences_attributes =
-                    { "foo" => { "id" => "test", "name" => "Test" } }
-                }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Preference with id\(s\)/)
+                    { 'foo' => { 'id' => 'test', 'name' => 'Test' } }
+                end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                   /Document\(s\) not found for class Preference/)
               end
             end
           end
@@ -4999,4 +5160,63 @@ describe Mongoid::Attributes::Nested do
       end
     end
   end
+
+  context 'when an id in nested attributes belongs to another parent' do
+    let(:victim) { Person.create! }
+    let(:attacker) { Person.create! }
+
+    context 'when the association is a has-many' do
+      before do
+        Person.send(:undef_method, :posts_attributes=)
+        Person.accepts_nested_attributes_for :posts
+      end
+
+      let!(:victim_post) { victim.posts.create!(title: 'Private') }
+
+      it 'does not update the other parent\'s document' do
+        expect { attacker.update!(posts_attributes: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_post.reload.title).to eq('Private')
+      end
+
+      it 'does not add the other parent\'s document to the association' do
+        expect { attacker.update!(posts_attributes: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(attacker.reload.posts).to be_empty
+      end
+
+      it 'does not update via a direct association assignment' do
+        expect { attacker.update!(posts: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_post.reload.title).to eq('Private')
+      end
+    end
+
+    context 'when the association is a has-and-belongs-to-many' do
+      before do
+        Person.send(:undef_method, :preferences_attributes=)
+        Person.accepts_nested_attributes_for :preferences
+      end
+
+      let!(:victim_preference) { victim.preferences.create!(name: 'Private') }
+
+      it 'does not update the other parent\'s document' do
+        expect { attacker.update!(preferences_attributes: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_preference.reload.name).to eq('Private')
+      end
+
+      it 'does not add the other parent\'s document to the association' do
+        expect { attacker.update!(preferences_attributes: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(attacker.reload.preferences).to be_empty
+      end
+
+      it 'does not update via a direct association assignment' do
+        expect { attacker.update!(preferences: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_preference.reload.name).to eq('Private')
+      end
+    end
+  end
 end

data/spec/mongoid/config/defaults_spec.rb

@@ -41,6 +41,18 @@ describe Mongoid::Config::Defaults do
       end
     end
 
+    shared_examples 'uses settings for 9.0' do
+      it 'uses settings for 9.0' do
+        expect(Mongoid.autosave_saves_unchanged_documents).to be true
+      end
+    end
+
+    shared_examples 'never allows reparenting via nested attributes' do
+      it 'leaves allow_reparenting_via_nested_attributes false' do
+        expect(Mongoid.allow_reparenting_via_nested_attributes).to be false
+      end
+    end
+
     context "when giving a valid version" do
 
       before do
@@ -57,6 +69,8 @@ describe Mongoid::Config::Defaults do
 
         it_behaves_like "uses settings for 8.0"
         it_behaves_like "uses settings for 8.1"
+        it_behaves_like 'uses settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
       end
 
       context "when the given version is 8.1" do
@@ -65,6 +79,8 @@ describe Mongoid::Config::Defaults do
 
         it_behaves_like "does not use settings for 8.0"
         it_behaves_like "uses settings for 8.1"
+        it_behaves_like 'uses settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
       end
 
       context "when the given version is 9.0" do
@@ -73,6 +89,8 @@ describe Mongoid::Config::Defaults do
 
         it_behaves_like "does not use settings for 8.0"
         it_behaves_like "does not use settings for 8.1"
+        it_behaves_like 'uses settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
       end
     end
 

data/spec/mongoid/config/encryption_spec.rb

@@ -75,6 +75,19 @@ describe Mongoid::Config::Encryption do
           end
         end
 
+        # Models are registered in class load order, and Rails eager loads
+        # app/models alphabetically, so a child whose file name sorts before
+        # its parent's arrives first.
+        context 'when the embedded model comes before its parent' do
+          let(:models) do
+            [ Crypt::Insurance, Crypt::Patient ]
+          end
+
+          it 'returns a map of encryption schemas' do
+            expect(encryption_schema_map).to eq(expected_schema_map)
+          end
+        end
+
         context 'and fields do not have encryption options' do
           let(:models) do
             [Crypt::Car]
@@ -109,6 +122,7 @@ describe Mongoid::Config::Encryption do
         let(:expected_schema_map) do
           {
             "mongoid_test.crypt_users" => {
+              'bsonType' => 'object',
               "properties" => {
                 "name" => {
                   "encrypt" => {
@@ -148,5 +162,219 @@ describe Mongoid::Config::Encryption do
         expect(encryption_schema_map).to eq({})
       end
     end
+
+    # A field left out of the schema map is written in plaintext, with no
+    # exception and nothing logged, so an omission here is silent data
+    # exposure rather than a broken feature.
+    context 'when the encrypted fields are on an embedded model' do
+      let(:token_properties) do
+        {
+          'bsonType' => 'object',
+          'properties' => {
+            'value' => {
+              'encrypt' => {
+                'bsonType' => 'string',
+                'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
+              }
+            }
+          }
+        }
+      end
+
+      context 'when two models embed the same encrypted model' do
+        let(:models) do
+          [ Crypt::Vault, Crypt::Chest ]
+        end
+
+        it 'maps the embedded model for the first parent' do
+          expect(encryption_schema_map.dig('mongoid_test.crypt_vaults', 'properties', 'token'))
+            .to eq(token_properties)
+        end
+
+        it 'maps the embedded model for the second parent' do
+          expect(encryption_schema_map.dig('mongoid_test.crypt_chests', 'properties', 'token'))
+            .to eq(token_properties)
+        end
+      end
+
+      context 'when one model embeds the same encrypted model twice' do
+        let(:models) do
+          [ Crypt::Ledger ]
+        end
+
+        it 'maps the first relation' do
+          expect(encryption_schema_map.dig('mongoid_test.crypt_ledgers', 'properties', 'primary_token'))
+            .to eq(token_properties)
+        end
+
+        it 'maps the second relation' do
+          expect(encryption_schema_map.dig('mongoid_test.crypt_ledgers', 'properties', 'backup_token'))
+            .to eq(token_properties)
+        end
+      end
+
+      # relation_class constantizes, and a polymorphic embedded_in has no class
+      # to resolve, so the walk has to look at the relation type first.
+      context 'when the embedded model is embedded polymorphically' do
+        let(:models) do
+          [ Crypt::Vault ]
+        end
+
+        it 'does not raise' do
+          expect { encryption_schema_map }.not_to raise_error
+        end
+      end
+
+      context 'when the embedded model comes before its parent' do
+        let(:models) do
+          [ Crypt::Token, Crypt::Vault ]
+        end
+
+        it 'maps the embedded model' do
+          expect(encryption_schema_map.dig('mongoid_test.crypt_vaults', 'properties', 'token'))
+            .to eq(token_properties)
+        end
+      end
+
+      context 'when the parent has no encrypted field of its own' do
+        let(:models) do
+          [ Crypt::Wallet, Crypt::Token ]
+        end
+
+        it 'maps the embedded model' do
+          expect(encryption_schema_map.dig('mongoid_test.crypt_wallets', 'properties', 'token'))
+            .to eq(token_properties)
+        end
+      end
+
+      context 'when the encrypted model is nested three levels deep' do
+        let(:account_properties) do
+          {
+            'bsonType' => 'object',
+            'properties' => {
+              'credential' => {
+                'bsonType' => 'object',
+                'properties' => {
+                  'secret' => {
+                    'encrypt' => {
+                      'bsonType' => 'string',
+                      'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
+                    }
+                  }
+                }
+              }
+            }
+          }
+        end
+
+        context 'when the models are listed outermost first' do
+          let(:models) do
+            [ Crypt::Owner, Crypt::Account, Crypt::Credential ]
+          end
+
+          it 'maps the whole subtree' do
+            expect(encryption_schema_map.dig('mongoid_test.crypt_owners', 'properties', 'account'))
+              .to eq(account_properties)
+          end
+        end
+
+        context 'when the middle model comes first' do
+          let(:models) do
+            [ Crypt::Account, Crypt::Owner, Crypt::Credential ]
+          end
+
+          it 'maps the whole subtree' do
+            expect(encryption_schema_map.dig('mongoid_test.crypt_owners', 'properties', 'account'))
+              .to eq(account_properties)
+          end
+        end
+      end
+
+      # The walk has to keep stopping at a model it is already inside of,
+      # otherwise a self-embedding model recurses forever.
+      context 'when a model embeds itself' do
+        let(:models) do
+          [ Crypt::Article ]
+        end
+
+        it 'terminates' do
+          expect { encryption_schema_map }.not_to raise_error
+        end
+
+        it 'maps the embedded model without descending into the cycle' do
+          expect(encryption_schema_map.dig('mongoid_test.crypt_articles', 'properties', 'comment')).to eq(
+            'bsonType' => 'object',
+            'properties' => {
+              'body' => {
+                'encrypt' => {
+                  'bsonType' => 'string',
+                  'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
+                }
+              }
+            }
+          )
+        end
+      end
+    end
+
+    context 'when an encrypted model has a callable database name' do
+      let(:models) do
+        [ Crypt::DynamicCar ]
+      end
+
+      it 'does not build a key from the unresolved callable' do
+        expect(encryption_schema_map.keys.grep(/Proc/)).to be_empty
+      end
+
+      it 'does not build a key that the model can never write to' do
+        expect(encryption_schema_map.keys).to all(satisfy { |key| key.count('.') == 1 })
+      end
+    end
+
+    context 'when an encrypted model has a callable database name that needs a tenant' do
+      let(:models) do
+        [ Crypt::TenantCar ]
+      end
+
+      # Resolving the callable while the map is built is not a fix: the
+      # documented multi-tenant idiom has no correct value at client
+      # construction time. Generating the map must not depend on it.
+      it 'does not raise' do
+        expect { encryption_schema_map }.not_to raise_error
+      end
+
+      it 'does not pin the map to whichever tenant happens to be current' do
+        Thread.current[:tenant_database] = 'tenant_a'
+        expect(encryption_schema_map.keys).not_to include('tenant_a.crypt_tenant_cars')
+      ensure
+        Thread.current[:tenant_database] = nil
+      end
+    end
+
+    # The map is generated over every model in the application, and a model may
+    # name an embedded class that is never defined. Resolving that name raises,
+    # which would take down every client build.
+    context 'when a model names an embedded class that is not defined' do
+      let(:models) do
+        [ Crypt::Drawer, Crypt::Cabinet ]
+      end
+
+      it 'does not raise' do
+        expect { encryption_schema_map }.not_to raise_error
+      end
+
+      it 'leaves out the model with nothing to encrypt' do
+        expect(encryption_schema_map.keys).not_to include('mongoid_test.crypt_drawers')
+      end
+
+      it 'still maps the encrypted fields of the model itself' do
+        expect(encryption_schema_map.dig('mongoid_test.crypt_cabinets', 'properties', 'label')).to eq(
+          'encrypt' => {
+            'bsonType' => 'string',
+            'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
+          }
+        )
+      end
+    end
   end
 end