mongoid 9.0.11 → 9.1.1

data/spec/mongoid/encryptable_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/crypt/models'
+
+describe Mongoid::Encryptable do
+  describe '.requires_encryption_schema?' do
+    context 'when the model declares encrypt_with' do
+      it 'returns true' do
+        expect(Crypt::Vault.requires_encryption_schema?).to be true
+      end
+    end
+
+    context 'when the model has an encrypted field' do
+      it 'returns true' do
+        expect(Crypt::User.requires_encryption_schema?).to be true
+      end
+    end
+
+    context 'when the model embeds an encrypted model' do
+      it 'returns true' do
+        expect(Crypt::Wallet.requires_encryption_schema?).to be true
+      end
+    end
+
+    context 'when the encrypted model is nested three levels deep' do
+      it 'returns true' do
+        expect(Crypt::Owner.requires_encryption_schema?).to be true
+      end
+    end
+
+    context 'when the model declares no encryption anywhere' do
+      it 'returns false' do
+        expect(Person.requires_encryption_schema?).to be false
+      end
+    end
+
+    # An association target does not have to be a Mongoid document. Truck
+    # embeds a plain Ruby class.
+    context 'when an embedded association target is not a document' do
+      it 'returns false' do
+        expect(Truck.requires_encryption_schema?).to be false
+      end
+    end
+
+    context 'when the model embeds itself' do
+      it 'terminates' do
+        expect(Crypt::Comment.requires_encryption_schema?).to be true
+      end
+    end
+
+    # Every model is asked this question, including ones naming an embedded
+    # class that is never defined. Such an association cannot be used, so
+    # nothing is embedded through it and nothing needs encrypting.
+    context 'when an embedded association names a class that is not defined' do
+      it 'returns false' do
+        expect(Crypt::Drawer.requires_encryption_schema?).to be false
+      end
+    end
+  end
+end

data/spec/mongoid/equality_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Equality do
-
   let(:klass) do
     Person
   end
@@ -13,25 +11,20 @@ describe Mongoid::Equality do
     Person.new
   end
 
-  describe "#==" do
-
-    context "when comparable is not a document" do
-
+  describe '#==' do
+    context 'when comparable is not a document' do
       let(:other) do
-        "Document"
+        'Document'
       end
 
-      it "returns false" do
-        expect(person).to_not eq(other)
+      it 'returns false' do
+        expect(person).not_to eq(other)
       end
     end
 
-    context "when comparable is a document" do
-
-      context "when it has the same id" do
-
-        context "when the classes are not the same" do
-
+    context 'when comparable is a document' do
+      context 'when it has the same id' do
+        context 'when the classes are not the same' do
           let(:other) do
             Post.new
           end
@@ -40,13 +33,12 @@ describe Mongoid::Equality do
             other.id = person.id
           end
 
-          it "returns false" do
-            expect(person).to_not eq(other)
+          it 'returns false' do
+            expect(person).not_to eq(other)
           end
         end
 
-        context "when the classes are the same" do
-
+        context 'when the classes are the same' do
           let(:other) do
             Person.new
           end
@@ -55,129 +47,111 @@ describe Mongoid::Equality do
             other.id = person.id
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(person).to eq(other)
           end
         end
       end
 
-      context "when it has a different id" do
-
+      context 'when it has a different id' do
         let(:other) do
           Person.new
         end
 
-        context "when the instances are the same" do
-
-          it "returns true" do
+        context 'when the instances are the same' do
+          it 'returns true' do
             expect(person).to eq(person)
           end
         end
 
-        context "when the instances are different" do
-
-          it "returns false" do
-            expect(person).to_not eq(other)
+        context 'when the instances are different' do
+          it 'returns false' do
+            expect(person).not_to eq(other)
           end
         end
       end
     end
   end
 
-  describe ".===" do
-
-    context "when comparable is an instance of this document" do
-
-      it "returns true" do
+  describe '.===' do
+    context 'when comparable is an instance of this document' do
+      it 'returns true' do
         expect(klass === person).to be true
       end
     end
 
-    context "when comparable is a relation of this document" do
-
+    context 'when comparable is a relation of this document' do
       let(:relation) do
         Post.new(person: person).person
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(klass === relation).to be true
       end
     end
 
-    context "when comparable is the same class" do
-
-      it "returns false" do
+    context 'when comparable is the same class' do
+      it 'returns false' do
         expect(klass === Person).to be false
       end
     end
 
-    context "when the comparable is a subclass" do
-
-      it "returns false" do
-        expect(Person === Doctor).to be false
+    context 'when the comparable is a subclass' do
+      it 'returns false' do
+        expect(Doctor.is_a?(Person)).to be false
       end
     end
 
-    context "when the comparable is an instance of a subclass" do
-
-      it "returns true" do
-        expect(Person === Doctor.new).to be true
+    context 'when the comparable is an instance of a subclass' do
+      it 'returns true' do
+        expect(Doctor.new.is_a?(Person)).to be true
       end
     end
   end
 
-  describe "#===" do
-
-    context "when comparable is the same type" do
-
-      context "when the instance is different" do
-
-        it "returns false" do
+  describe '#===' do
+    context 'when comparable is the same type' do
+      context 'when the instance is different' do
+        it 'returns false' do
           expect(person === Person.new).to be false
         end
       end
 
-      context "when the instance is the same" do
-
-        it "returns true" do
-          expect(person === person).to be true
+      context 'when the instance is the same' do
+        it 'returns true' do
+          expect(person === person).to be true # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
         end
       end
     end
 
-    context "when the comparable is a subclass" do
-
-      it "returns false" do
+    context 'when the comparable is a subclass' do
+      it 'returns false' do
         expect(person === Doctor.new).to be false
       end
     end
 
-    context "when comparing to a class" do
-      context "when the class is the same" do
-
-        it "returns false" do
+    context 'when comparing to a class' do
+      context 'when the class is the same' do
+        it 'returns false' do
           expect(person === Person).to be false
         end
       end
 
-      context "when the class is a subclass" do
-
-        it "returns false" do
+      context 'when the class is a subclass' do
+        it 'returns false' do
           expect(person === Doctor).to be false
         end
       end
 
-      context "when the class is a superclass" do
-
-        it "returns false" do
+      context 'when the class is a superclass' do
+        it 'returns false' do
           expect(Doctor.new === Person).to be false
         end
       end
     end
   end
 
-  describe "#<=>" do
-
+  describe '#<=>' do
     let(:first) do
       Person.new
     end
@@ -186,60 +160,53 @@ describe Mongoid::Equality do
       Person.new
     end
 
-    it "compares based on the document id" do
+    it 'compares based on the document id' do
       expect(first <=> second).to eq(-1)
     end
-    
+
     it "doesn't break if one isn't a document" do
       expect do
-        first <=> "Foo"
-      end.to_not raise_error
+        first <=> 'Foo'
+      end.not_to raise_error
     end
   end
 
-  describe "#eql?" do
-
-    context "when comparable is not a document" do
-
+  describe '#eql?' do
+    context 'when comparable is not a document' do
       let(:other) do
-        "Document"
+        'Document'
       end
 
-      it "returns false" do
-        expect(person).to_not be_eql(other)
+      it 'returns false' do
+        expect(person).not_to eql(other)
       end
     end
 
-    context "when comparable is a document" do
-
+    context 'when comparable is a document' do
       let(:other) do
         Person.new
       end
 
-      context "when it has the same id" do
-
+      context 'when it has the same id' do
         before do
           other.id = person.id
         end
 
-        it "returns true" do
-          expect(person).to be_eql(other)
+        it 'returns true' do
+          expect(person).to eql(other)
         end
       end
 
-      context "when it has a different id" do
-
-        context "when the instances are the same" do
-
-          it "returns true" do
-            expect(person).to be_eql(person)
+      context 'when it has a different id' do
+        context 'when the instances are the same' do
+          it 'returns true' do
+            expect(person).to eql(person)
           end
         end
 
-        context "when the instances are different" do
-
-          it "returns false" do
-            expect(person).to_not be_eql(other)
+        context 'when the instances are different' do
+          it 'returns false' do
+            expect(person).not_to eql(other)
           end
         end
       end

data/spec/mongoid/errors/ambiguous_relationship_spec.rb

@@ -1,31 +1,28 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'spec_helper'
 
 describe Mongoid::Errors::AmbiguousRelationship do
-
-  describe "#message" do
-
+  describe '#message' do
     let(:error) do
-      described_class.new(Person, Drug, :person, [ :drugs, :evil_drugs ])
+      described_class.new(Person, Drug, :person, %i[drugs evil_drugs])
     end
 
-    it "contains the problem in the message" do
+    it 'contains the problem in the message' do
       expect(error.message).to include(
-        "Ambiguous associations :drugs, :evil_drugs defined on Person."
+        'Ambiguous associations :drugs, :evil_drugs defined on Person.'
       )
     end
 
-    it "contains the summary in the message" do
+    it 'contains the summary in the message' do
       expect(error.message).to include(
-        "When Mongoid attempts to set an inverse document of an association in memory"
+        'When Mongoid attempts to set an inverse document of an association in memory'
       )
     end
 
-    it "contains the resolution in the message" do
+    it 'contains the resolution in the message' do
       expect(error.message).to include(
-        "On the :person association on Drug you must add an :inverse_of option"
+        'On the :person association on Drug you must add an :inverse_of option'
       )
     end
   end

data/spec/mongoid/errors/attribute_not_loaded_spec.rb

@@ -1,31 +1,28 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Errors::AttributeNotLoaded do
-
-  describe "#message" do
-
+  describe '#message' do
     let(:error) do
       described_class.new(Band, :label)
     end
 
-    it "contains the problem in the message" do
+    it 'contains the problem in the message' do
       expect(error.message).to include(
         "Attempted to access attribute 'label' on Band which was not loaded."
       )
     end
 
-    it "contains the summary in the message" do
+    it 'contains the summary in the message' do
       expect(error.message).to include(
-        "You loaded an instance of Band using a query projection method"
+        'You loaded an instance of Band using a query projection method'
       )
     end
 
-    it "contains the resolution in the message" do
+    it 'contains the resolution in the message' do
       expect(error.message).to include(
-        "Ensure your query projection methods such as `.only` and `.without`"
+        'Ensure your query projection methods such as `.only` and `.without`'
       )
     end
   end

data/spec/mongoid/errors/callback_spec.rb

@@ -1,31 +1,28 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Errors::Callback do
-
-  describe "#message" do
-
+  describe '#message' do
     let(:error) do
       described_class.new(Post, :create!)
     end
 
-    it "contains the problem in the message" do
+    it 'contains the problem in the message' do
       expect(error.message).to include(
-        "Calling create! on Post resulted in a false return from a callback."
+        'Calling create! on Post resulted in a false return from a callback.'
       )
     end
 
-    it "contains the summary in the message" do
+    it 'contains the summary in the message' do
       expect(error.message).to include(
-        "If a before callback returns false when using Document.create!"
+        'If a before callback returns false when using Document.create!'
       )
     end
 
-    it "contains the resolution in the message" do
+    it 'contains the resolution in the message' do
       expect(error.message).to include(
-        "Double check all before callbacks to make sure they are not"
+        'Double check all before callbacks to make sure they are not'
       )
     end
   end

data/spec/mongoid/errors/config_redactor_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongoid::Errors::ConfigRedactor do
+  describe '.redact' do
+    subject(:redacted) { described_class.redact(config) }
+
+    context 'when the config is not a hash' do
+      let(:config) { 'not a hash' }
+
+      it 'returns the value unchanged' do
+        expect(redacted).to eq('not a hash')
+      end
+    end
+
+    context 'when the config has a :password key' do
+      let(:config) { { hosts: [ 'localhost:27017' ], password: 's3cr3t' } }
+
+      it 'replaces the password value' do
+        expect(redacted[:password]).to eq('[REDACTED]')
+      end
+
+      it 'leaves other values intact' do
+        expect(redacted[:hosts]).to eq([ 'localhost:27017' ])
+      end
+    end
+
+    context 'when the config has a string "password" key' do
+      let(:config) { { 'password' => 's3cr3t' } }
+
+      it 'replaces the password value' do
+        expect(redacted['password']).to eq('[REDACTED]')
+      end
+    end
+
+    context 'when the config has a :uri with embedded credentials' do
+      let(:config) { { uri: 'mongodb://admin:s3cr3t@cluster.example.com/db' } }
+
+      it 'strips the userinfo from the URI' do
+        expect(redacted[:uri]).to eq('mongodb://[REDACTED]@cluster.example.com/db')
+      end
+    end
+
+    context 'when the config has a mongodb+srv URI' do
+      let(:config) { { uri: 'mongodb+srv://admin:s3cr3t@cluster.example.com/db' } }
+
+      it 'strips the userinfo from the URI' do
+        expect(redacted[:uri]).to eq('mongodb+srv://[REDACTED]@cluster.example.com/db')
+      end
+    end
+
+    context 'when the URI has no userinfo' do
+      let(:config) { { uri: 'mongodb://cluster.example.com/db' } }
+
+      it 'leaves the URI unchanged' do
+        expect(redacted[:uri]).to eq('mongodb://cluster.example.com/db')
+      end
+    end
+
+    context 'when the URI value is not a string' do
+      let(:config) { { uri: nil } }
+
+      it 'leaves the value unchanged' do
+        expect(redacted[:uri]).to be_nil
+      end
+    end
+
+    context 'when the config has nested auto_encryption_options' do
+      let(:kms) do
+        {
+          aws: { access_key_id: 'AKIA...', secret_access_key: 'secret-value' },
+          local: { key: 'A' * 96 }
+        }
+      end
+      let(:config) do
+        {
+          database: 'mongoid_test',
+          options: {
+            auto_encryption_options: {
+              key_vault_namespace: 'admin.datakeys',
+              kms_providers: kms
+            }
+          }
+        }
+      end
+
+      it 'redacts the entire auto_encryption_options value' do
+        expect(redacted[:options][:auto_encryption_options]).to eq('[REDACTED]')
+      end
+
+      it 'preserves sibling values in the parent hash' do
+        expect(redacted[:database]).to eq('mongoid_test')
+      end
+
+      it 'does not contain any kms secret in its serialized form' do
+        expect(redacted.to_s).not_to include('secret-value')
+        expect(redacted.to_s).not_to include('AKIA')
+        expect(redacted.to_s).not_to include('A' * 96)
+      end
+    end
+
+    context 'when redaction would mutate the input' do
+      let(:config) { { password: 's3cr3t', options: { foo: 'bar' } } }
+
+      it 'does not modify the original hash' do
+        described_class.redact(config)
+        expect(config[:password]).to eq('s3cr3t')
+      end
+    end
+  end
+end

data/spec/mongoid/errors/delete_restriction_spec.rb

@@ -1,29 +1,26 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Errors::DeleteRestriction do
-
-  describe "#message" do
-
+  describe '#message' do
     let(:error) do
       described_class.new(Person.new, :drugs)
     end
 
-    it "contains the problem in the message" do
+    it 'contains the problem in the message' do
       expect(error.message).to include(
         "Cannot destroy Person because of dependent 'drugs'."
       )
     end
 
-    it "contains the summary in the message" do
+    it 'contains the summary in the message' do
       expect(error.message).to include(
         "When defining 'drugs' with a :dependent => :restrict_with_error,"
       )
     end
 
-    it "contains the resolution in the message" do
+    it 'contains the resolution in the message' do
       expect(error.message).to include(
         "Don't attempt to delete the parent Person when it has children"
       )

data/spec/mongoid/errors/document_not_destroyed_spec.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Errors::DocumentNotDestroyed do
-
-  describe "#message" do
-
+  describe '#message' do
     let(:post) do
       Post.new
     end
@@ -15,21 +12,21 @@ describe Mongoid::Errors::DocumentNotDestroyed do
       described_class.new(post.id, Post)
     end
 
-    it "contains the problem in the message" do
+    it 'contains the problem in the message' do
       expect(error.message).to include(
         "Post with id #{post.id.inspect} was not destroyed"
       )
     end
 
-    it "contains the summary in the message" do
+    it 'contains the summary in the message' do
       expect(error.message).to include(
-        "When calling Post#destroy! and a callback halts the destroy callback"
+        'When calling Post#destroy! and a callback halts the destroy callback'
       )
     end
 
-    it "contains the resolution in the message" do
+    it 'contains the resolution in the message' do
       expect(error.message).to include(
-        "Check the before/after destroy callbacks to ensure"
+        'Check the before/after destroy callbacks to ensure'
       )
     end
   end