mongoid 9.0.11 → 9.1.1

data/spec/mongoid/collection_configurable_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::CollectionConfigurable do
-
   before(:all) do
     class CollectionConfigurableValidOptions
       include Mongoid::Document
@@ -45,7 +43,7 @@ describe Mongoid::CollectionConfigurable do
     Object.send(:remove_const, :CollectionConfigurableInvalidOptions)
   end
 
-  after(:each) do
+  after do
     [
       CollectionConfigurableValidOptions,
       CollectionConfigurableUnknownOptions
@@ -59,15 +57,14 @@ describe Mongoid::CollectionConfigurable do
       let(:subject) do
         CollectionConfigurableValidOptions
       end
-
-      before(:each) do
-        subject.create_collection
-      end
-
       let(:coll_options) do
         subject.collection.database.list_collections(filter: { name: subject.collection_name.to_s }).first
       end
 
+      before do
+        subject.create_collection
+      end
+
       it 'creates the collection' do
         expect(coll_options).not_to be_nil
       end
@@ -110,7 +107,7 @@ describe Mongoid::CollectionConfigurable do
 
     context 'when force is false' do
       let(:logger) do
-        double("logger").tap do |log|
+        double('logger').tap do |log|
           expect(log).to receive(:debug).once.with(/Collection '#{subject.collection_name}' already exist/)
         end
       end
@@ -127,7 +124,7 @@ describe Mongoid::CollectionConfigurable do
 
     context 'when force is true' do
       let(:logger) do
-        double("logger")
+        double('logger')
       end
 
       let(:coll_options) do
@@ -140,7 +137,7 @@ describe Mongoid::CollectionConfigurable do
       end
 
       it 'does not log a message' do
-        expect(logger).to receive(:debug).never.with(/Collection '#{subject.collection_name}' already exist/)
+        expect(logger).not_to receive(:debug).with(/Collection '#{subject.collection_name}' already exist/)
         subject.create_collection(force: true)
       end
 

data/spec/mongoid/composable_spec.rb

@@ -1,22 +1,16 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Composable do
-
-  describe ".prohibited_methods" do
-
+  describe '.prohibited_methods' do
     let(:methods) do
       described_class.prohibited_methods
     end
 
     Mongoid::Composable::MODULES.each do |mod|
-
       context "when checking in #{mod}" do
-
         mod.instance_methods.each do |method|
-
           it "includes #{method}" do
             expect(methods).to include(method.to_sym)
           end
@@ -25,7 +19,6 @@ describe Mongoid::Composable do
     end
 
     Mongoid::Composable::RESERVED_METHOD_NAMES.each do |name|
-
       it "includes the method names #{name}" do
         expect(methods).to include(name)
       end

data/spec/mongoid/config/defaults_spec.rb

@@ -1,30 +1,27 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Config::Defaults do
-
   let(:config) do
     Mongoid::Config
   end
 
-  describe ".load_defaults" do
-
-    shared_examples "uses settings for 8.0" do
-      it "uses settings for 8.0" do
+  describe '.load_defaults' do
+    shared_examples 'uses settings for 8.0' do
+      it 'uses settings for 8.0' do
         expect(Mongoid.legacy_readonly).to be true
       end
     end
 
-    shared_examples "does not use settings for 8.0" do
-      it "does not use settings for 8.0" do
+    shared_examples 'does not use settings for 8.0' do
+      it 'does not use settings for 8.0' do
         expect(Mongoid.legacy_readonly).to be false
       end
     end
 
-    shared_examples "uses settings for 8.1" do
-      it "uses settings for 8.1" do
+    shared_examples 'uses settings for 8.1' do
+      it 'uses settings for 8.1' do
         expect(Mongoid.immutable_ids).to be false
         expect(Mongoid.legacy_persistence_context_behavior).to be true
         expect(Mongoid.around_callbacks_for_embeds).to be true
@@ -32,8 +29,8 @@ describe Mongoid::Config::Defaults do
       end
     end
 
-    shared_examples "does not use settings for 8.1" do
-      it "does not use settings for 8.1" do
+    shared_examples 'does not use settings for 8.1' do
+      it 'does not use settings for 8.1' do
         expect(Mongoid.immutable_ids).to be true
         expect(Mongoid.legacy_persistence_context_behavior).to be false
         expect(Mongoid.around_callbacks_for_embeds).to be false
@@ -41,8 +38,25 @@ describe Mongoid::Config::Defaults do
       end
     end
 
-    context "when giving a valid version" do
+    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 'does not use settings for 9.0' do
+      it 'does not use settings for 9.0' do
+        expect(Mongoid.autosave_saves_unchanged_documents).to be false
+      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
         config.load_defaults(version)
       end
@@ -51,45 +65,57 @@ describe Mongoid::Config::Defaults do
         Mongoid::Config.reset
       end
 
-      context "when the given version is 8.0" do
-
+      context 'when the given version is 8.0' do
         let(:version) { 8.0 }
 
-        it_behaves_like "uses settings for 8.0"
-        it_behaves_like "uses settings for 8.1"
+        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
-
+      context 'when the given version is 8.1' do
         let(:version) { 8.1 }
 
-        it_behaves_like "does not use settings for 8.0"
-        it_behaves_like "uses settings for 8.1"
+        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
-
+      context 'when the given version is 9.0' do
         let(:version) { 9.0 }
 
-        it_behaves_like "does not use settings for 8.0"
-        it_behaves_like "does not use settings for 8.1"
+        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
+
+      context 'when the given version is 9.1' do
+        let(:version) { 9.1 }
+
+        it_behaves_like 'does not use settings for 8.0'
+        it_behaves_like 'does not use settings for 8.1'
+        it_behaves_like 'does not use settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
       end
     end
 
-    context "when given version a version which is no longer supported" do
+    context 'when given version a version which is no longer supported' do
       let(:version) { 7.5 }
 
-      it "raises an error" do
+      it 'raises an error' do
         expect do
           config.load_defaults(version)
         end.to raise_error(ArgumentError, 'Version no longer supported: 7.5')
       end
     end
 
-    context "when given version an invalid version" do
+    context 'when given version an invalid version' do
       let(:version) { '4,2' }
 
-      it "raises an error" do
+      it 'raises an error' do
         expect do
           config.load_defaults(version)
         end.to raise_error(ArgumentError, 'Unknown version: 4,2')

data/spec/mongoid/config/encryption_spec.rb

@@ -1,44 +1,41 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
-require "support/crypt/models"
+require 'spec_helper'
+require 'support/crypt/models'
 
 describe Mongoid::Config::Encryption do
-
-  describe ".encryption_schema_map" do
-
+  describe '.encryption_schema_map' do
     let(:encryption_schema_map) do
       Mongoid.config.encryption_schema_map(database_id, models)
     end
 
-    context "when a model has encrypted fields" do
+    context 'when a model has encrypted fields' do
       context 'when model has encrypt_metadata' do
         let(:expected_schema_map) do
           {
-            "mongoid_test.crypt_patients" => {
-              "bsonType" => "object",
-              "encryptMetadata" => {
-                "keyId" => [BSON::Binary.new(Base64.decode64("grolrnFVSSW9Gq04Q87R9Q=="), :uuid)]
+            'mongoid_test.crypt_patients' => {
+              'bsonType' => 'object',
+              'encryptMetadata' => {
+                'keyId' => [ BSON::Binary.new(Base64.decode64('grolrnFVSSW9Gq04Q87R9Q=='), :uuid) ]
               },
-              "properties" => {
-                "medical_records" => {
-                  "encrypt" => {
-                    "bsonType" => "array",
-                    "algorithm" => "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
+              'properties' => {
+                'medical_records' => {
+                  'encrypt' => {
+                    'bsonType' => 'array',
+                    'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
                   }
                 },
-                "blood_type" => {
-                  "encrypt" => {
-                    "keyId" => "/blood_type_key_name",
-                    "bsonType" => "string",
-                    "algorithm" => "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
+                'blood_type' => {
+                  'encrypt' => {
+                    'keyId' => '/blood_type_key_name',
+                    'bsonType' => 'string',
+                    'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
                   }
                 },
-                "ssn" => {
-                  "encrypt" => {
-                    "bsonType" => "int",
-                    "algorithm" => "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+                'ssn' => {
+                  'encrypt' => {
+                    'bsonType' => 'int',
+                    'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
                   }
                 },
                 'insurance' => {
@@ -52,46 +49,59 @@ describe Mongoid::Config::Encryption do
                     }
                   }
                 }
-              },
+              }
             }
           }
         end
 
         let(:models) do
-          [Crypt::Patient]
+          [ Crypt::Patient ]
         end
 
-        it "returns a map of encryption schemas" do
+        it 'returns a map of encryption schemas' do
           expect(encryption_schema_map).to eq(expected_schema_map)
         end
 
-        context "when models are related" do
+        context 'when models are related' do
+          let(:models) do
+            [ Crypt::Patient, Crypt::Insurance ]
+          end
+
+          it 'returns a map of encryption schemas' do
+            expect(encryption_schema_map).to eq(expected_schema_map)
+          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::Patient, Crypt::Insurance]
+            [ Crypt::Insurance, Crypt::Patient ]
           end
 
-          it "returns a map of encryption schemas" do
+          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]
+            [ Crypt::Car ]
           end
 
           let(:expected_schema_map) do
             {
-              "vehicles.crypt_cars" => {
-                "bsonType" => "object",
-                "encryptMetadata" => {
-                  "keyId" => [BSON::Binary.new(Base64.decode64("grolrnFVSSW9Gq04Q87R9Q=="), :uuid)],
-                  "algorithm" => "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+              'vehicles.crypt_cars' => {
+                'bsonType' => 'object',
+                'encryptMetadata' => {
+                  'keyId' => [ BSON::Binary.new(Base64.decode64('grolrnFVSSW9Gq04Q87R9Q=='), :uuid) ],
+                  'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
                 },
-                "properties" => {
-                  "vin" => {
-                    "encrypt" => {
-                      "bsonType" => "string"
+                'properties' => {
+                  'vin' => {
+                    'encrypt' => {
+                      'bsonType' => 'string'
                     }
                   }
                 }
@@ -99,7 +109,7 @@ describe Mongoid::Config::Encryption do
             }
           end
 
-          it "returns a map of encryption schemas" do
+          it 'returns a map of encryption schemas' do
             expect(encryption_schema_map).to eq(expected_schema_map)
           end
         end
@@ -108,20 +118,21 @@ describe Mongoid::Config::Encryption do
       context 'when model does not have encrypt_metadata' do
         let(:expected_schema_map) do
           {
-            "mongoid_test.crypt_users" => {
-              "properties" => {
-                "name" => {
-                  "encrypt" => {
-                    'keyId' => [BSON::Binary.new(Base64.decode64("grolrnFVSSW9Gq04Q87R9Q=="), :uuid)],
-                    "bsonType" => "string",
-                    "algorithm" => "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
+            'mongoid_test.crypt_users' => {
+              'bsonType' => 'object',
+              'properties' => {
+                'name' => {
+                  'encrypt' => {
+                    'keyId' => [ BSON::Binary.new(Base64.decode64('grolrnFVSSW9Gq04Q87R9Q=='), :uuid) ],
+                    'bsonType' => 'string',
+                    'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
                   }
                 },
-                "email" => {
-                  "encrypt" => {
-                    'keyId' => [BSON::Binary.new(Base64.decode64("S34mE/HhSFSym3yErpER6Q=="), :uuid)],
-                    "bsonType" => "string",
-                    "algorithm" => "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+                'email' => {
+                  'encrypt' => {
+                    'keyId' => [ BSON::Binary.new(Base64.decode64('S34mE/HhSFSym3yErpER6Q=='), :uuid) ],
+                    'bsonType' => 'string',
+                    'algorithm' => 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'
                   }
                 }
               }
@@ -130,10 +141,10 @@ describe Mongoid::Config::Encryption do
         end
 
         let(:models) do
-          [Crypt::User]
+          [ Crypt::User ]
         end
 
-        it "returns a map of encryption schemas" do
+        it 'returns a map of encryption schemas' do
           expect(encryption_schema_map).to eq(expected_schema_map)
         end
       end
@@ -141,12 +152,226 @@ describe Mongoid::Config::Encryption do
 
     context 'when a model does not have encrypted fields' do
       let(:models) do
-        [Person]
+        [ Person ]
       end
 
       it 'returns an empty map' 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