mongoid 9.0.12 → 9.1.0

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,20 +38,7 @@ 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
-
+    context 'when giving a valid version' do
       before do
         config.load_defaults(version)
       end
@@ -63,51 +47,42 @@ 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 9.0'
-        it_behaves_like 'never allows reparenting via nested attributes'
+        it_behaves_like 'uses settings for 8.0'
+        it_behaves_like 'uses settings for 8.1'
       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 'uses settings for 9.0'
-        it_behaves_like 'never allows reparenting via nested attributes'
+        it_behaves_like 'does not use settings for 8.0'
+        it_behaves_like 'uses settings for 8.1'
       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 'uses settings for 9.0'
-        it_behaves_like 'never allows reparenting via nested attributes'
+        it_behaves_like 'does not use settings for 8.0'
+        it_behaves_like 'does not use settings for 8.1'
       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,35 +49,22 @@ 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
-          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
+        context 'when models are related' do
           let(:models) do
-            [ Crypt::Insurance, Crypt::Patient ]
+            [ Crypt::Patient, Crypt::Insurance ]
           end
 
           it 'returns a map of encryption schemas' do
@@ -90,21 +74,21 @@ describe Mongoid::Config::Encryption do
 
         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'
                     }
                   }
                 }
@@ -112,7 +96,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
@@ -121,21 +105,20 @@ describe Mongoid::Config::Encryption do
       context 'when model does not have encrypt_metadata' do
         let(:expected_schema_map) do
           {
-            "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"
+            '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'
                   }
                 },
-                "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'
                   }
                 }
               }
@@ -144,10 +127,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
@@ -155,226 +138,12 @@ 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