mongoid 9.1.1 → 9.1.2

data/spec/integration/encryption_spec.rb

@@ -245,4 +245,153 @@ describe 'Encryption' do
       end
     end
   end
+
+  # The schema map has one entry per namespace, and it has to cover every model
+  # that writes there: models sharing a collection, subclasses, and subclasses
+  # of embedded models. Documents are read back through a client without
+  # automatic encryption, to see what is actually stored.
+  describe 'when more than one model writes to a namespace' do
+    let(:root_models) do
+      [ Crypt::Badge, Crypt::BadgeScan, Crypt::Member, Crypt::Listing, Crypt::Box, Crypt::Locker ]
+    end
+
+    let(:keyed_models) do
+      [ Crypt::Badge, Crypt::BadgeScan, Crypt::Member, Crypt::PrivateListing, Crypt::Box, Crypt::SecretContent ]
+    end
+
+    around do |example|
+      original_options = root_models.to_h { |model| [ model, model.storage_options ] }
+      existing_key_ids = keyed_models.to_h { |model| [ model, model.encrypt_metadata[:key_id] ] }
+      keyed_models.each { |model| model.set_key_id(data_key_id) }
+      root_models.each do |model|
+        unencrypted_client[model.collection_name.to_s].drop
+        model.store_in(client: :encrypted)
+      end
+      # The schema map is generated when the client is built, so the client has
+      # to be built after the key ids above are in place.
+      Mongoid::Clients.clear
+
+      example.run
+
+      original_options.each { |model, options| model.storage_options = options }
+      existing_key_ids.each { |model, key_id| model.set_key_id(key_id) }
+      Mongoid::Clients.clear
+    end
+
+    def stored_document(model, id)
+      unencrypted_client[model.collection_name.to_s].find(_id: id).first
+    end
+
+    def expect_ciphertext(value)
+      expect(value).to be_a(BSON::Binary).and(have_attributes(type: :ciphertext))
+    end
+
+    context 'when two models are stored in one collection' do
+      it 'stores the fields of both models encrypted', :aggregate_failures do
+        badge = Crypt::Badge.create!(serial: 'SERIAL-1')
+        scan = Crypt::BadgeScan.create!(holder: 'HOLDER-1')
+
+        expect_ciphertext(stored_document(Crypt::Badge, badge.id)['serial'])
+        expect_ciphertext(stored_document(Crypt::BadgeScan, scan.id)['holder'])
+      end
+    end
+
+    context 'when a subclass adds an encrypted field to an encrypted parent' do
+      it 'stores the fields of the parent and of the subclass encrypted', :aggregate_failures do
+        employee = Crypt::Employee.create!(ssn: 'SSN-1', salary: 'SALARY-1')
+
+        stored_document(Crypt::Member, employee.id).tap do |doc|
+          expect_ciphertext(doc['ssn'])
+          expect_ciphertext(doc['salary'])
+        end
+      end
+
+      it 'stores the fields of a sibling subclass encrypted' do
+        contractor = Crypt::Contractor.create!(ssn: 'SSN-2', rate: 'RATE-1')
+
+        expect_ciphertext(stored_document(Crypt::Member, contractor.id)['rate'])
+      end
+
+      it 'reads the fields back' do
+        employee = Crypt::Employee.create!(ssn: 'SSN-3', salary: 'SALARY-3')
+
+        expect(Crypt::Member.find(employee.id).salary).to eq('SALARY-3')
+      end
+    end
+
+    context 'when only a subclass has encrypted fields' do
+      it 'stores the fields of the subclass encrypted' do
+        listing = Crypt::PrivateListing.create!(title: 'TITLE-1', owner_ssn: 'SSN-4')
+
+        expect_ciphertext(stored_document(Crypt::Listing, listing.id)['owner_ssn'])
+      end
+    end
+
+    context 'when a subclass of an embeds_one target adds an encrypted field' do
+      it 'stores the fields of the target and of the subclass encrypted', :aggregate_failures do
+        box = Crypt::Box.create!(item: Crypt::SealedItem.new(label: 'LABEL-1', seal: 'SEAL-1'))
+
+        stored_document(Crypt::Box, box.id)['item'].tap do |item|
+          expect_ciphertext(item['label'])
+          expect_ciphertext(item['seal'])
+        end
+      end
+    end
+
+    context 'when only a subclass of an embeds_one target has encrypted fields' do
+      it 'stores the fields of the subclass encrypted' do
+        locker = Crypt::Locker.create!(content: Crypt::SecretContent.new(label: 'LABEL-2', code: 'CODE-1'))
+
+        expect_ciphertext(stored_document(Crypt::Locker, locker.id)['content']['code'])
+      end
+    end
+
+    # An entry for the namespace exists, but it does not cover every encrypted
+    # field of the model. The driver encrypts what the entry lists and writes
+    # the rest in plaintext.
+    context 'when the schema entry for the namespace misses an encrypted field' do
+      let(:config) do
+        super().merge(
+          partial: {
+            hosts: SpecConfig.instance.addresses,
+            database: database_id,
+            options: {
+              auto_encryption_options: {
+                key_vault_client: :key_vault,
+                kms_providers: kms_providers,
+                key_vault_namespace: key_vault_namespace,
+                extra_options: extra_options,
+                schema_map: partial_schema_map
+              }
+            }
+          }
+        )
+      end
+
+      let(:partial_schema_map) do
+        {
+          "#{database_id}.#{Crypt::Member.collection_name}" => {
+            'bsonType' => 'object',
+            'encryptMetadata' => {
+              'keyId' => [ BSON::Binary.new(Base64.decode64(data_key_id), :uuid) ],
+              'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
+            },
+            'properties' => {
+              'ssn' => { 'encrypt' => { 'bsonType' => 'string' } }
+            }
+          }
+        }
+      end
+
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect do
+          Crypt::Employee.with(client: :partial) { |klass| klass.create!(ssn: 'SSN-5', salary: 'PARTIAL-1') }
+        end.to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          unencrypted_client[Crypt::Member.collection_name.to_s].find(salary: 'PARTIAL-1').to_a
+        ).to be_empty
+      end
+    end
+  end
 end

data/spec/mongoid/association/accessors_spec.rb

@@ -689,6 +689,41 @@ describe Mongoid::Association::Accessors do
         end
       end
     end
+
+    context 'when the document has a stored field named like a referenced association' do
+      before(:all) do
+        class Musician
+          include Mongoid::Document
+
+          belongs_to :orchestra, optional: true
+        end
+
+        class Orchestra
+          include Mongoid::Document
+
+          has_many :musicians
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :Orchestra)
+        Object.send(:remove_const, :Musician)
+      end
+
+      # The musicians used to be embedded, so the stored orchestra still holds
+      # the old array under the association's name.
+      let!(:orchestra_id) do
+        BSON::ObjectId.new.tap do |id|
+          Orchestra.collection.insert_one('_id' => id, 'musicians' => [ { '_id' => BSON::ObjectId.new } ])
+        end
+      end
+
+      let!(:musician) { Musician.create!(orchestra_id: orchestra_id) }
+
+      it 'loads the association by its key' do
+        expect(Orchestra.find(orchestra_id).musicians.to_a).to eq([ musician ])
+      end
+    end
   end
 
   context 'when setting associations to empty values' do

data/spec/mongoid/association/referenced/has_and_belongs_to_many/buildable_spec.rb

@@ -107,6 +107,17 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
       end
     end
 
+    context 'when provided an empty array' do
+      let(:object) do
+        []
+      end
+
+      it 'returns an empty criteria' do
+        expect(documents).to be_a(Mongoid::Criteria)
+        expect(documents.empty_and_chainable?).to be true
+      end
+    end
+
     context 'when provided a object' do
       context 'when the object is not nil' do
         let(:object) do

data/spec/mongoid/atomic/modifiers_spec.rb

@@ -74,6 +74,78 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when a conflicting modification exists' do
+      context 'when the conflicting modification is a set' do
+        let(:sets) do
+          { 'addresses.0.street' => 'Bond' }
+        end
+
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        before do
+          modifiers.set(sets)
+          modifiers.add_to_set(adds)
+        end
+
+        it 'adds the add to set modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$set' => { 'addresses.0.street' => 'Bond' },
+              conflicts: { '$addToSet' =>
+                { 'addresses.0.tags' => { '$each' => %w[tag] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a push' do
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        before do
+          modifiers.push(pushes)
+          modifiers.add_to_set(adds)
+        end
+
+        it 'adds the add to set modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$push' => { 'addresses' => { '$each' => [ { 'street' => 'Oxford St' } ] } },
+              conflicts: { '$addToSet' =>
+                { 'addresses.0.tags' => { '$each' => %w[tag] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a pull' do
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        before do
+          modifiers.pull(pulls)
+          modifiers.add_to_set(adds)
+        end
+
+        it 'does not split the operations, leaving MongoDB to reject the update' do
+          # A $pull shifts array elements, so applying the $addToSet in a
+          # separate write afterwards could target a different element.
+          expect(modifiers).to eq(
+            { '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } },
+              '$addToSet' => { 'addresses.0.tags' => { '$each' => %w[tag] } } }
+          )
+        end
+      end
+    end
   end
 
   describe '#pull' do
@@ -125,6 +197,98 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when a conflicting modification exists' do
+      # A $pull shifts the positions of the remaining elements, so it stays in
+      # the main update. MongoDB rejects the update if the paths overlap.
+      context 'when the conflicting modification is a set' do
+        let(:sets) do
+          { 'addresses.0.street' => 'Bond' }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.set(sets)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$set' => { 'addresses.0.street' => 'Bond' },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a push' do
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.push(pushes)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$push' => { 'addresses' => { '$each' => [ { 'street' => 'Oxford St' } ] } },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is an add to set' do
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$addToSet' => { 'addresses.0.tags' => { '$each' => %w[tag] } },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a pull all' do
+        let(:pull_alls) do
+          { 'addresses' => [ { '_id' => 'one' } ] }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.pull_all(pull_alls)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$pullAll' => { 'addresses' => [ { '_id' => 'one' } ] },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+    end
   end
 
   describe '#pull_all' do
@@ -183,6 +347,54 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when a conflicting modification exists' do
+      context 'when the conflicting modification is a pull' do
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        let(:pull_alls) do
+          { 'addresses' => [ { '_id' => 'one' } ] }
+        end
+
+        before do
+          modifiers.pull(pulls)
+          modifiers.pull_all(pull_alls)
+        end
+
+        it 'adds the pull all modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } },
+              conflicts: { '$pullAll' =>
+                { 'addresses' => [ { '_id' => 'one' } ] } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a push' do
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        let(:pull_alls) do
+          { 'addresses' => [ { '_id' => 'one' } ] }
+        end
+
+        before do
+          modifiers.push(pushes)
+          modifiers.pull_all(pull_alls)
+        end
+
+        it 'adds the pull all modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$push' => { 'addresses' => { '$each' => [ { 'street' => 'Oxford St' } ] } },
+              conflicts: { '$pullAll' =>
+                { 'addresses' => [ { '_id' => 'one' } ] } } }
+          )
+        end
+      end
+    end
   end
 
   describe '#push' do
@@ -321,6 +533,56 @@ describe Mongoid::Atomic::Modifiers do
           )
         end
       end
+
+      context 'when the conflicting modification is an add to set' do
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.push(pushes)
+        end
+
+        it 'adds the push modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$addToSet' => { 'addresses.0.tags' => { '$each' => %w[tag] } },
+              conflicts: { '$push' =>
+                { 'addresses' => { '$each' => [
+                  { 'street' => 'Oxford St' }
+                ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is an unset' do
+        let(:unsets) do
+          [ 'addresses.0.street' ]
+        end
+
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        before do
+          modifiers.unset(unsets)
+          modifiers.push(pushes)
+        end
+
+        it 'adds the push modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$unset' => { 'addresses.0.street' => true },
+              conflicts: { '$push' =>
+                { 'addresses' => { '$each' => [
+                  { 'street' => 'Oxford St' }
+                ] } } } }
+          )
+        end
+      end
     end
 
     context 'when there is another operation on a sibling of a key which is nested' do
@@ -419,6 +681,30 @@ describe Mongoid::Atomic::Modifiers do
           )
         end
       end
+
+      context 'when the conflicting modification is an add to set' do
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        let(:sets) do
+          { 'addresses.0.title' => 'Sir' }
+        end
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.set(sets)
+        end
+
+        it 'adds the set modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$addToSet' =>
+              { 'addresses.0.tags' => { '$each' => %w[tag] } },
+              conflicts:
+                { '$set' => { 'addresses.0.title' => 'Sir' } } }
+          )
+        end
+      end
     end
   end
 
@@ -488,6 +774,67 @@ describe Mongoid::Atomic::Modifiers do
           end
         end
       end
+
+      context 'when the unsets conflict with a prior push' do
+        # A $push appends to the array and does not shift existing element
+        # positions, so the $unset can be applied safely in a separate write.
+        let(:pushes) { { 'books' => { 'title' => '1984' } } }
+
+        let(:unsets) { [ 'books.0.title' ] }
+
+        before do
+          modifiers.push(pushes)
+          modifiers.unset(unsets)
+        end
+
+        it 'adds the unset modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$push' => { 'books' => { '$each' => [ { 'title' => '1984' } ] } },
+              conflicts: { '$unset' => { 'books.0.title' => true } } }
+          )
+        end
+      end
+
+      context 'when the unsets conflict with a prior add to set' do
+        let(:adds) { { 'books.0.tags' => %w[tag] } }
+
+        let(:unsets) { [ 'books.0.title' ] }
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.unset(unsets)
+        end
+
+        it 'adds the unset modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$addToSet' => { 'books.0.tags' => { '$each' => %w[tag] } },
+              conflicts: { '$unset' => { 'books.0.title' => true } } }
+          )
+        end
+      end
+
+      context 'when there is a pending pull on the same field' do
+        # A $pull shifts array elements, so routing the $unset into a separate
+        # write could make it target a different element. The operations are
+        # left together so MongoDB rejects the update (code 40) atomically.
+        let(:pulls) do
+          { 'books' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        let(:unsets) { [ 'books.0.title' ] }
+
+        before do
+          modifiers.pull(pulls)
+          modifiers.unset(unsets)
+        end
+
+        it 'does not split the operations' do
+          expect(modifiers).to eq(
+            { '$pull' => { 'books' => { '_id' => { '$in' => [ 'one' ] } } },
+              '$unset' => { 'books.0.title' => true } }
+          )
+        end
+      end
     end
   end
 end

data/spec/mongoid/attributes/nested_spec.rb

@@ -290,6 +290,35 @@ describe Mongoid::Attributes::Nested do
       end
     end
 
+    context 'when a has-many association uses a custom primary key' do
+      # A throwaway class, so that accepts_nested_attributes_for does not
+      # leave autosave callbacks and nested attributes on a shared model.
+      let(:company_class) do
+        stub_const('NestedSpecCompany', Class.new do
+          include Mongoid::Document
+
+          store_in collection: 'hmm_companies'
+          field :p, type: Integer
+          has_many :emails, primary_key: :p, foreign_key: :f, class_name: 'HmmEmail', inverse_of: nil
+          accepts_nested_attributes_for :emails
+        end)
+      end
+
+      after do
+        Mongoid.deregister_model(company_class)
+      end
+
+      it 'reports the parent primary key value in the error params' do
+        company = company_class.create!(p: 42)
+
+        expect do
+          company.emails_attributes = { '0' => { 'id' => 'missing', 'f' => 42 } }
+        end.to raise_error(Mongoid::Errors::DocumentNotFound) { |error|
+          expect(error.params).to eq({ _id: 'missing', 'f' => 42 })
+        }
+      end
+    end
+
     context 'when the relation is a has-and-belongs-to-many' do
       before do
         Person.send(:undef_method, :preferences_attributes=)

data/spec/mongoid/clients/factory_spec.rb

@@ -331,6 +331,42 @@ describe Mongoid::Clients::Factory do
           end
         end
       end
+
+      context 'when bypass_auto_encryption is set' do
+        it 'warns that encryption is bypassed' do
+          expect(Mongoid::Warnings).to receive(:warn_bypass_auto_encryption)
+
+          described_class.send(
+            :build_auto_encryption_options,
+            { auto_encryption_options: { bypass_auto_encryption: true, schema_map: {} } },
+            database_id
+          )
+        end
+      end
+
+      context 'when bypass_auto_encryption is not set' do
+        it 'does not warn' do
+          expect(Mongoid::Warnings).not_to receive(:warn_bypass_auto_encryption)
+
+          described_class.send(
+            :build_auto_encryption_options,
+            { auto_encryption_options: { schema_map: {} } },
+            database_id
+          )
+        end
+      end
+
+      context 'when bypass_auto_encryption is false' do
+        it 'does not warn' do
+          expect(Mongoid::Warnings).not_to receive(:warn_bypass_auto_encryption)
+
+          described_class.send(
+            :build_auto_encryption_options,
+            { auto_encryption_options: { bypass_auto_encryption: false, schema_map: {} } },
+            database_id
+          )
+        end
+      end
     end
 
     context 'when no name is provided' do