mongoid 9.0.11 → 9.1.1

data/spec/integration/dots_and_dollars_spec.rb

@@ -1,277 +1,272 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
-describe "Dots and Dollars" do
+describe 'Dots and Dollars' do
   min_server_version '5.0'
 
   before(:all) do
     class DADMUser
       include Mongoid::Document
-      field :"first.last", type: String, default: "Neil.Shweky"
-      field :"$_amount", type: Integer, default: 0
-      field :"$a.b", type: Boolean, default: true
+
+      field :'first.last', type: String, default: 'Neil.Shweky'
+      field :$_amount, type: Integer, default: 0
+      field :'$a.b', type: Boolean, default: true
     end
   end
 
   let!(:user) { DADMUser.create! }
 
-  describe "accessing the fields" do
-
-    context "when using the field getters" do
-
-      context "on dotted fields" do
-        it "gets the right value" do
-          expect(user.send(:"first.last")).to eq("Neil.Shweky")
+  describe 'accessing the fields' do
+    context 'when using the field getters' do
+      context 'on dotted fields' do
+        it 'gets the right value' do
+          expect(user.send(:'first.last')).to eq('Neil.Shweky')
         end
       end
 
-      context "on dollared fields" do
-        it "gets the right value" do
-          expect(user.send(:"$_amount")).to eq(0)
+      context 'on dollared fields' do
+        it 'gets the right value' do
+          expect(user.send(:$_amount)).to eq(0)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "gets the right value" do
-          expect(user.send(:"$a.b")).to be true
+      context 'on dotted and dollared fields' do
+        it 'gets the right value' do
+          expect(user.send(:'$a.b')).to be true
         end
       end
     end
 
-    context "when using the read_attribute" do
-
-      context "on dotted fields" do
-        it "gets the right value" do
-          expect(user.read_attribute("first.last")).to eq("Neil.Shweky")
+    context 'when using the read_attribute' do
+      context 'on dotted fields' do
+        it 'gets the right value' do
+          expect(user.read_attribute('first.last')).to eq('Neil.Shweky')
         end
       end
 
-      context "on dollared fields" do
-        it "gets the right value" do
-          expect(user.read_attribute("$_amount")).to eq(0)
+      context 'on dollared fields' do
+        it 'gets the right value' do
+          expect(user.read_attribute('$_amount')).to eq(0)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "gets the right value" do
-          expect(user.read_attribute("$a.b")).to be true
+      context 'on dotted and dollared fields' do
+        it 'gets the right value' do
+          expect(user.read_attribute('$a.b')).to be true
         end
       end
     end
 
-    context "when using the field setters" do
-
-      context "on dotted fields" do
-        it "raises an error" do
+    context 'when using the field setters' do
+      context 'on dotted fields' do
+        it 'raises an error' do
           expect do
-            user.send(:"first.last=", "Nissim.Shweky")
+            user.send(:'first.last=', 'Nissim.Shweky')
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dollared fields" do
-        it "raises an error" do
+      context 'on dollared fields' do
+        it 'raises an error' do
           expect do
-            user.send(:"$_amount=", 1)
+            user.send(:'$_amount=', 1)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "raises an error" do
+      context 'on dotted and dollared fields' do
+        it 'raises an error' do
           expect do
-            user.send(:"$a.b=", false)
+            user.send(:'$a.b=', false)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
     end
 
-    context "when updating via write_attribute" do
-
-      context "on dotted fields" do
-        it "raises an error" do
+    context 'when updating via write_attribute' do
+      context 'on dotted fields' do
+        it 'raises an error' do
           expect do
-            user.write_attribute("first.last", "Nissim.Shweky")
+            user.write_attribute('first.last', 'Nissim.Shweky')
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dollared fields" do
-        it "raises an error" do
+      context 'on dollared fields' do
+        it 'raises an error' do
           expect do
-            user.write_attribute("$_amount", 1)
+            user.write_attribute('$_amount', 1)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "raises an error" do
+      context 'on dotted and dollared fields' do
+        it 'raises an error' do
           expect do
-            user.write_attribute("$a.b", false)
+            user.write_attribute('$a.b', false)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
     end
 
-    context "when updating via update_attribute" do
-
-      context "on dotted fields" do
-        it "raises an error" do
+    context 'when updating via update_attribute' do
+      context 'on dotted fields' do
+        it 'raises an error' do
           expect do
-            user.update_attribute("first.last", "Nissim.Shweky")
+            user.update_attribute('first.last', 'Nissim.Shweky')
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dollared fields" do
-        it "raises an error" do
+      context 'on dollared fields' do
+        it 'raises an error' do
           expect do
-            user.update_attribute("$_amount", 1)
+            user.update_attribute('$_amount', 1)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "raises an error" do
+      context 'on dotted and dollared fields' do
+        it 'raises an error' do
           expect do
-            user.update_attribute("$a.b", false)
+            user.update_attribute('$a.b', false)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
     end
 
-    context "when updating via update_attributes!" do
-
-      context "on dotted fields" do
-        it "raises an error" do
+    context 'when updating via update_attributes!' do
+      context 'on dotted fields' do
+        it 'raises an error' do
           expect do
-            user.update_attributes!("first.last": "Nissim.Shweky")
+            user.update_attributes!('first.last': 'Nissim.Shweky')
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dollared fields" do
-        it "raises an error" do
+      context 'on dollared fields' do
+        it 'raises an error' do
           expect do
-            user.update_attributes!("$_amount": 1)
+            user.update_attributes!('$_amount': 1)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "raises an error" do
+      context 'on dotted and dollared fields' do
+        it 'raises an error' do
           expect do
-            user.update_attributes!("$a.b": false)
+            user.update_attributes!('$a.b': false)
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
     end
 
-    context "when updating via []=" do
-
-      context "on dotted fields" do
-        it "raises an error" do
+    context 'when updating via []=' do
+      context 'on dotted fields' do
+        it 'raises an error' do
           expect do
-            user[:"first.last"] = "Nissim.Shweky"
+            user[:'first.last'] = 'Nissim.Shweky'
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dollared fields" do
-        it "raises an error" do
+      context 'on dollared fields' do
+        it 'raises an error' do
           expect do
-            user[:"$_amount"] = 1
+            user[:$_amount] = 1
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "raises an error" do
+      context 'on dotted and dollared fields' do
+        it 'raises an error' do
           expect do
-            user[:"$a.b"] = false
+            user[:'$a.b'] = false
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
     end
 
-    context "when updating via remove_attribute" do
-
-      context "on dotted fields" do
-        it "raises an error" do
+    context 'when updating via remove_attribute' do
+      context 'on dotted fields' do
+        it 'raises an error' do
           expect do
-            user.remove_attribute("first.last")
+            user.remove_attribute('first.last')
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dollared fields" do
-        it "raises an error" do
+      context 'on dollared fields' do
+        it 'raises an error' do
           expect do
-            user.remove_attribute("$_amount")
+            user.remove_attribute('$_amount')
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
 
-      context "on dotted and dollared fields" do
-        it "raises an error" do
+      context 'on dotted and dollared fields' do
+        it 'raises an error' do
           expect do
-            user.remove_attribute("$a.b")
+            user.remove_attribute('$a.b')
           end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
         end
       end
     end
   end
 
-  describe "persisting to the db" do
-
-    context "when saving to the db" do
-
+  describe 'persisting to the db' do
+    context 'when saving to the db' do
       let(:user) { DADMUser.new }
 
-      it "the save succeeds" do
+      it 'the save succeeds' do
         expect do
           user.save!
-        end.to_not raise_error
+        end.not_to raise_error
       end
     end
 
-    context "when retrieving it from the db" do
-
+    context 'when retrieving it from the db' do
       let(:from_db) { DADMUser.first }
 
-      it "has the fields populated correctly" do
-        expect(from_db.attributes["first.last"]).to eq("Neil.Shweky")
-        expect(from_db.attributes["$_amount"]).to eq(0)
-        expect(from_db.attributes["$a.b"]).to eq(true)
+      it 'has the fields populated correctly' do
+        expect(from_db.attributes['first.last']).to eq('Neil.Shweky')
+        expect(from_db.attributes['$_amount']).to eq(0)
+        expect(from_db.attributes['$a.b']).to eq(true)
       end
     end
   end
 
-  describe "querying that field" do
-
-    context "when attempting to query a dotted field" do
-
+  describe 'querying that field' do
+    context 'when attempting to query a dotted field' do
       let(:queried) do
-        DADMUser.where("first.last": "Neil.Shweky").first
+        DADMUser.where('first.last': 'Neil.Shweky').first
       end
 
-      it "does not work" do
-        expect(queried).to be nil
+      it 'does not work' do
+        expect(queried).to be_nil
       end
     end
 
-    context "when attempting to query a dollared field" do
-
+    context 'when attempting to query a dollared field' do
       let(:queried) do
-        DADMUser.where("$_amount": 0).first
+        DADMUser.where('$_amount': 0).first
       end
 
-      it "raise an error" do
+      it 'raises an error' do
         expect do
           queried
-        end.to raise_error(Mongo::Error::OperationFailure)
+        end.to raise_error(Mongoid::Errors::InvalidQuery)
+      end
+
+      context 'when allow_unsafe_query_operators is true' do
+        config_override :allow_unsafe_query_operators, true
+
+        it 'raises an error from the server' do
+          expect do
+            queried
+          end.to raise_error(Mongo::Error::OperationFailure)
+        end
       end
     end
   end

data/spec/integration/encryption_spec.rb

@@ -1,4 +1,3 @@
-# rubocop:todo all
 require 'spec_helper'
 require 'support/crypt/models'
 
@@ -34,29 +33,34 @@ describe 'Encryption' do
   around do |example|
     Mongoid.default_client[Crypt::Patient.collection_name].drop
     Mongoid.default_client[Crypt::Car.collection_name].drop
+    Mongoid.default_client[Crypt::Folder.collection_name].drop
     existing_key_id = Crypt::Patient.encrypt_metadata[:key_id]
     Crypt::Patient.set_key_id(data_key_id)
     Crypt::Car.set_key_id(data_key_id)
+    Crypt::Note.set_key_id(data_key_id)
     Mongoid::Config.send(:clients=, config)
     Mongoid::Clients.with_name(:key_vault)[key_vault_collection].drop
     Crypt::Patient.store_in(client: :encrypted)
     Crypt::Car.store_in(client: :encrypted, database: Crypt::Car.storage_options[:database])
+    Crypt::Folder.store_in(client: :encrypted)
 
     example.run
 
     Crypt::Patient.reset_storage_options!
+    Crypt::Folder.reset_storage_options!
     Crypt::Patient.set_key_id(existing_key_id)
     Crypt::Car.set_key_id(existing_key_id)
+    Crypt::Note.set_key_id(existing_key_id)
   end
 
   it 'encrypts and decrypts fields' do
     patient = Crypt::Patient.create!(
       code: '12345',
-      medical_records: ['one', 'two', 'three'],
+      medical_records: %w[one two three],
       blood_type: 'A+',
       blood_type_key_name: key_alt_name,
-      ssn: 123456789,
-      insurance: Crypt::Insurance.new(policy_number: 123456789)
+      ssn: 123_456_789,
+      insurance: Crypt::Insurance.new(policy_number: 123_456_789)
     )
     Crypt::Patient.find(patient.id).tap do |found_patient|
       expect(found_patient.code).to eq(patient.code)
@@ -70,11 +74,11 @@ describe 'Encryption' do
   it 'stores data encrypted in the database' do
     patient = Crypt::Patient.create!(
       code: '12345',
-      medical_records: ['one', 'two', 'three'],
+      medical_records: %w[one two three],
       blood_type: 'A+',
       blood_type_key_name: key_alt_name,
-      ssn: 123456789,
-      insurance: Crypt::Insurance.new(policy_number: 123456789)
+      ssn: 123_456_789,
+      insurance: Crypt::Insurance.new(policy_number: 123_456_789)
     )
     unencrypted_client[Crypt::Patient.collection.name].find(_id: patient.id).first.tap do |doc|
       %w[medical_records blood_type ssn].each do |field|
@@ -86,15 +90,159 @@ describe 'Encryption' do
     end
   end
 
+  # Nothing about the parent document says it needs a schema: it has no
+  # encrypted field of its own and no encrypt_with. Its collection still needs
+  # one, or the embedded field goes out in the clear.
+  it 'stores an embedded field encrypted when the parent has no encrypted field' do
+    folder = Crypt::Folder.create!(note: Crypt::Note.new(text: 'SECRET'))
+    unencrypted_client[Crypt::Folder.collection.name].find(_id: folder.id).first.tap do |doc|
+      expect(doc['note']['text']).to be_a(BSON::Binary)
+      expect(doc['note']['text'].type).to eq(:ciphertext)
+    end
+  end
+
   it 'stores data encrypted in the non-default database' do
     car = Crypt::Car.create!(vin: 'VA1234')
     unencrypted_client
       .use(Crypt::Car.storage_options[:database])[Crypt::Car.collection.name]
       .find(_id: car.id).first.tap do |doc|
-        expect(doc[:vin]).to be_a(BSON::Binary)
-        expect(doc[:vin].type).to eq(:ciphertext)
+      expect(doc[:vin]).to be_a(BSON::Binary)
+      expect(doc[:vin].type).to eq(:ciphertext)
     end
   end
 
+  # The encryption schema map is keyed by namespace and built once, when the
+  # client is constructed. Whenever the namespace an encrypted model actually
+  # writes to is not in that map, the driver encrypts nothing and reports no
+  # error, so the field lands in the clear. Mongoid fails closed instead.
+  describe 'when the target namespace is not in the encryption schema map' do
+    let(:scratch_databases) do
+      %w[vehicles_dynamic vehicles_tenant_b vehicles_tenant_c tenant_a]
+    end
+
+    around do |example|
+      original_options = {
+        Crypt::DynamicCar => Crypt::DynamicCar.storage_options,
+        Crypt::TenantCar => Crypt::TenantCar.storage_options
+      }
+      existing_key_ids = original_options.keys.to_h { |model| [ model, model.encrypt_metadata[:key_id] ] }
+      original_options.each_key do |model|
+        model.set_key_id(data_key_id)
+        model.store_in(client: :encrypted)
+      end
+      clean_scratch_data
+      # The schema map is generated when the client is built, so the client has
+      # to be built after the storage options above are in place.
+      Mongoid::Clients.clear
+
+      example.run
+
+      clean_scratch_data
+      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 clean_scratch_data
+      scratch_databases.each { |database| unencrypted_client.use(database).database.drop }
+      # Crypt::Car writes into the shared 'vehicles' database, which other
+      # examples rely on, so remove only the documents these examples create.
+      unencrypted_client
+        .use(Crypt::Car.storage_options[:database])[Crypt::Car.collection_name.to_s]
+        .delete_many(vin: { '$in' => %w[CLIENT-1 CLIENT-2] })
+    end
+
+    # Reads with a client that has no automatic encryption, to see what really
+    # landed on disk.
+    def documents_with_plaintext_vin(database, collection, vin)
+      unencrypted_client.use(database)[collection].find(vin: vin).to_a
+    end
+
+    context 'when the database name is a callable' do
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::DynamicCar.create!(vin: 'DYNAMIC-1') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles_dynamic', Crypt::DynamicCar.collection_name.to_s, 'DYNAMIC-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the database name is a callable resolved per tenant' do
+      around do |example|
+        Thread.current[:tenant_database] = 'tenant_a'
+        example.run
+        Thread.current[:tenant_database] = nil
+      end
+
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::TenantCar.create!(vin: 'TENANT-1') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('tenant_a', Crypt::TenantCar.collection_name.to_s, 'TENANT-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the database is overridden for the block' do
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.with(database: 'vehicles_tenant_b') { |car| car.create!(vin: 'BLOCK-1') } }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles_tenant_b', Crypt::Car.collection_name.to_s, 'BLOCK-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the database is overridden globally' do
+      persistence_context_override :database, 'vehicles_tenant_c'
 
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.create!(vin: 'GLOBAL-1') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles_tenant_c', Crypt::Car.collection_name.to_s, 'GLOBAL-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the model is routed to a client without automatic encryption' do
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.with(client: :default) { |car| car.create!(vin: 'CLIENT-1') } }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles', Crypt::Car.collection_name.to_s, 'CLIENT-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the parent has no encrypted field of its own' do
+      it 'does not store the embedded field in plaintext', :aggregate_failures do
+        expect { Crypt::Folder.with(client: :default) { |folder| folder.create!(note: Crypt::Note.new(text: 'EMBEDDED-1')) } }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          unencrypted_client[Crypt::Folder.collection_name.to_s].find('note.text' => 'EMBEDDED-1').to_a
+        ).to be_empty
+      end
+    end
+
+    context 'when the client is overridden globally to one without automatic encryption' do
+      persistence_context_override :client, :default
+
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.create!(vin: 'CLIENT-2') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles', Crypt::Car.collection_name.to_s, 'CLIENT-2')
+        ).to be_empty
+      end
+    end
+  end
 end

data/spec/integration/i18n_fallbacks_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'spec_helper'
 
@@ -17,11 +16,11 @@ describe 'i18n fallbacks' do
       it 'uses active locale' do
         product = Product.new
         I18n.locale = :de
-        product.description = "Marvelous in German"
+        product.description = 'Marvelous in German'
         I18n.locale = :en
-        product.description = "Marvelous!"
+        product.description = 'Marvelous!'
         I18n.locale = :de
-        product.description.should == 'Marvelous in German'
+        product.description.should eq 'Marvelous in German'
       end
     end
 
@@ -29,9 +28,9 @@ describe 'i18n fallbacks' do
       it 'falls back on default locale' do
         product = Product.new
         I18n.locale = :en
-        product.description = "Marvelous!"
+        product.description = 'Marvelous!'
         I18n.locale = :de
-        product.description.should == 'Marvelous!'
+        product.description.should eq 'Marvelous!'
       end
     end
 
@@ -39,9 +38,9 @@ describe 'i18n fallbacks' do
       it 'returns nil' do
         product = Product.new
         I18n.locale = :en
-        product.description = "Marvelous!"
+        product.description = 'Marvelous!'
         I18n.locale = :ru
-        product.description.should be nil
+        product.description.should be_nil
       end
     end
   end