mongoid 9.0.11 → 9.1.1

data/spec/mongoid/validatable/associated_spec.rb

@@ -1,41 +1,35 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Validatable::AssociatedValidator do
-
-  describe "#valid?" do
-
-    context "when validating associated on both sides" do
-
-      context "when the documents are valid" do
-
+  describe '#valid?' do
+    context 'when validating associated on both sides' do
+      context 'when the documents are valid' do
         let(:user) do
-          User.new(name: "test")
+          User.new(name: 'test')
         end
 
         let(:description) do
-          Description.new(details: "testing")
+          Description.new(details: 'testing')
         end
 
         before do
           user.descriptions << description
         end
 
-        it "only validates the parent once" do
+        it 'only validates the parent once' do
           expect(user).to be_valid
         end
 
-        it "only validates the child once" do
+        it 'only validates the child once' do
           expect(description).to be_valid
         end
       end
 
-      context "when the documents are not valid" do
-
+      context 'when the documents are not valid' do
         let(:user) do
-          User.new(name: "test")
+          User.new(name: 'test')
         end
 
         let(:description1) do
@@ -52,28 +46,27 @@ describe Mongoid::Validatable::AssociatedValidator do
           user.valid?
         end
 
-        it "only validates the parent once" do
-          expect(user).to_not be_valid
+        it 'only validates the parent once' do
+          expect(user).not_to be_valid
         end
 
-        it "adds the errors from the relation" do
-          expect(user.errors[:descriptions]).to_not be_nil
+        it 'adds the errors from the relation' do
+          expect(user.errors[:descriptions]).not_to be_nil
         end
 
         it 'reports all failed validations' do
           errors = user.descriptions.flat_map { |d| d.errors[:details] }
-          expect(errors.length).to be == 2
+          expect(errors.length).to eq 2
         end
 
-        it "only validates the child once" do
-          expect(description1).to_not be_valid
+        it 'only validates the child once' do
+          expect(description1).not_to be_valid
         end
       end
 
-      context "when the documents are flagged for destroy" do
-
+      context 'when the documents are flagged for destroy' do
         let(:user) do
-          User.new(name: "test")
+          User.new(name: 'test')
         end
 
         let(:description) do
@@ -85,17 +78,33 @@ describe Mongoid::Validatable::AssociatedValidator do
           user.descriptions << description
         end
 
-        it "does not run validation on them" do
+        it 'does not run validation on them' do
           expect(user).to be_valid
         end
-
       end
 
+      context 'when a child document has been destroyed' do
+        let(:user) do
+          User.new(name: 'test')
+        end
+
+        let(:description) do
+          Description.new
+        end
+
+        before do
+          user.descriptions << description
+          description.destroyed = true
+        end
+
+        it 'does not run validation on the destroyed child' do
+          expect(user).to be_valid
+        end
+      end
     end
   end
 
-  describe "#validate" do
-
+  describe '#validate' do
     let(:person) do
       Person.new
     end
@@ -104,98 +113,90 @@ describe Mongoid::Validatable::AssociatedValidator do
       described_class.new(attributes: person.relations.keys)
     end
 
-    context "when the association is a one to one" do
-
-      context "when the association is nil" do
-
+    context 'when the association is a one to one' do
+      context 'when the association is nil' do
         before do
           validator.validate(person)
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(person.errors[:name]).to be_empty
         end
       end
 
-      context "when the association is valid" do
+      context 'when the association is valid' do
         before do
           person.name = Name.new(first_name: 'A', last_name: 'B')
           validator.validate(person)
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(person.errors[:name]).to be_empty
         end
       end
 
-      context "when the association is invalid" do
-
+      context 'when the association is invalid' do
         before do
           person.name = Name.new(first_name: 'Jamis', last_name: 'Buck')
           validator.validate(person)
         end
 
-        it "adds errors to the parent document" do
-          expect(person.errors[:name]).to_not be_empty
+        it 'adds errors to the parent document' do
+          expect(person.errors[:name]).not_to be_empty
         end
 
-        it "translates the error in english" do
-          expect(person.errors[:name][0]).to eq("is invalid")
+        it 'translates the error in english' do
+          expect(person.errors[:name][0]).to eq('is invalid')
         end
       end
     end
 
-    context "when the association is a one to many" do
-
-      context "when the association is empty" do
-
+    context 'when the association is a one to many' do
+      context 'when the association is empty' do
         before do
           validator.validate(person)
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(person.errors[:addresses]).to be_empty
         end
       end
 
-      context "when the association has invalid documents" do
-
+      context 'when the association has invalid documents' do
         before do
           person.addresses << Address.new(street: '123')
           validator.validate(person)
         end
 
-        it "adds errors to the parent document" do
-          expect(person.errors[:addresses]).to_not be_empty
+        it 'adds errors to the parent document' do
+          expect(person.errors[:addresses]).not_to be_empty
         end
       end
 
-      context "when the association has all valid documents" do
-
+      context 'when the association has all valid documents' do
         before do
           person.addresses << Address.new(street: '123 First St')
           person.addresses << Address.new(street: '456 Second St')
           validator.validate(person)
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(person.errors[:addresses]).to be_empty
         end
       end
     end
   end
 
-  context "when describing validation on the instance level" do
-
+  context 'when describing validation on the instance level' do
     let!(:dictionary) do
-      Dictionary.create!(name: "en")
+      Dictionary.create!(name: 'en')
     end
 
     let(:validators) do
       dictionary.validates_associated :words
     end
 
-    it "adds the validation only to the instance" do
+    it 'adds the validation only to the instance' do
       expect(validators).to eq([ described_class ])
     end
   end

data/spec/mongoid/validatable/format_spec.rb

@@ -1,84 +1,74 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Validatable::FormatValidator do
-
-  describe "#validate_each" do
-
+  describe '#validate_each' do
     let(:product) do
       Product.new
     end
 
-    context "when the field is not localized" do
-
+    context 'when the field is not localized' do
       let(:validator) do
-        described_class.new(attributes: [:brand_name], with: /\A[a-z]*\z/i)
+        described_class.new(attributes: [ :brand_name ], with: /\A[a-z]*\z/i)
       end
 
-      context "when the value is valid" do
-
+      context 'when the value is valid' do
         before do
-          validator.validate_each(product, :brand_name, "Apple")
+          validator.validate_each(product, :brand_name, 'Apple')
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(product.errors[:brand_name]).to be_empty
         end
       end
 
-      context "when the value is invalid" do
-
+      context 'when the value is invalid' do
         before do
-          validator.validate_each(product, :brand_name, "123")
+          validator.validate_each(product, :brand_name, '123')
         end
 
-        it "adds errors" do
-          expect(product.errors[:brand_name]).to eq(["is invalid"])
+        it 'adds errors' do
+          expect(product.errors[:brand_name]).to eq([ 'is invalid' ])
         end
       end
     end
 
-    context "when the field is localized" do
-
+    context 'when the field is localized' do
       let(:validator) do
-        described_class.new(attributes: [:website], with: URI.regexp)
+        described_class.new(attributes: [ :website ], with: URI::DEFAULT_PARSER.make_regexp)
       end
 
-      context "when the localized value is valid" do
-
+      context 'when the localized value is valid' do
         before do
-          validator.validate_each(product, :website, { "en" => "http://www.apple.com" })
+          validator.validate_each(product, :website, { 'en' => 'http://www.apple.com' })
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(product.errors[:website]).to be_empty
         end
       end
 
-      context "when one of the localized values is invalid" do
-
+      context 'when one of the localized values is invalid' do
         before do
           validator.validate_each(
             product,
-            :website, { "en" => "http://www.apple.com", "fr" => "not_a_website" }
+            :website, { 'en' => 'http://www.apple.com', 'fr' => 'not_a_website' }
           )
         end
 
-        it "adds errors" do
-          expect(product.errors[:website]).to eq(["is invalid"])
+        it 'adds errors' do
+          expect(product.errors[:website]).to eq([ 'is invalid' ])
         end
       end
 
-      context "when the localized value is invalid" do
-
+      context 'when the localized value is invalid' do
         before do
-          validator.validate_each(product, :website, { "en" => "not_a_website" })
+          validator.validate_each(product, :website, { 'en' => 'not_a_website' })
         end
 
-        it "adds errors" do
-          expect(product.errors[:website]).to eq(["is invalid"])
+        it 'adds errors' do
+          expect(product.errors[:website]).to eq([ 'is invalid' ])
         end
       end
     end

data/spec/mongoid/validatable/length_spec.rb

@@ -1,201 +1,179 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Validatable::LengthValidator do
-
-  describe "#validate_each" do
-
+  describe '#validate_each' do
     let(:product) do
       Product.new
     end
 
-    context "when the field is not localized" do
-
+    context 'when the field is not localized' do
       let(:validator) do
-        described_class.new(attributes: [:brand_name], in: 1..5)
+        described_class.new(attributes: [ :brand_name ], in: 1..5)
       end
 
-      context "when the value is valid" do
-
+      context 'when the value is valid' do
         before do
-          validator.validate_each(product, :brand_name, "Apple")
+          validator.validate_each(product, :brand_name, 'Apple')
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(product.errors[:brand_name]).to be_empty
         end
       end
 
-      context "when the value is invalid" do
-
+      context 'when the value is invalid' do
         before do
-          validator.validate_each(product, :brand_name, "123456")
+          validator.validate_each(product, :brand_name, '123456')
         end
 
-        it "adds errors" do
+        it 'adds errors' do
           expect(product.errors[:brand_name]).to eq(
-            ["is too long (maximum is 5 characters)"]
+            [ 'is too long (maximum is 5 characters)' ]
           )
         end
       end
     end
 
-    context "when the field is localized" do
-
+    context 'when the field is localized' do
       let(:validator) do
-        described_class.new(attributes: [:website], in: 1..5)
+        described_class.new(attributes: [ :website ], in: 1..5)
       end
 
-      context "when the localized value is valid" do
-
+      context 'when the localized value is valid' do
         before do
-          validator.validate_each(product, :website, { "en" => "12345" })
+          validator.validate_each(product, :website, { 'en' => '12345' })
         end
 
-        it "adds no errors" do
+        it 'adds no errors' do
           expect(product.errors[:website]).to be_empty
         end
       end
 
-      context "when one of the localized values is invalid" do
-
+      context 'when one of the localized values is invalid' do
         before do
           validator.validate_each(
             product,
-            :website, { "en" => "12345", "fr" => "123456" }
+            :website, { 'en' => '12345', 'fr' => '123456' }
           )
         end
 
-        it "adds errors" do
+        it 'adds errors' do
           expect(product.errors[:website]).to eq(
-            ["is too long (maximum is 5 characters)"]
+            [ 'is too long (maximum is 5 characters)' ]
           )
         end
       end
 
-      context "when the localized value is invalid" do
-
+      context 'when the localized value is invalid' do
         before do
-          validator.validate_each(product, :website, { "en" => "123456" })
+          validator.validate_each(product, :website, { 'en' => '123456' })
         end
 
-        it "adds errors" do
+        it 'adds errors' do
           expect(product.errors[:website]).to eq(
-            ["is too long (maximum is 5 characters)"]
+            [ 'is too long (maximum is 5 characters)' ]
           )
         end
       end
     end
 
-    context "when the field is aliased" do
-
-      context "when the aliased field name is validated" do
-
+    context 'when the field is aliased' do
+      context 'when the aliased field name is validated' do
         let(:validator) do
-          described_class.new(attributes: [:sku], in: 1..5)
+          described_class.new(attributes: [ :sku ], in: 1..5)
         end
 
-        context "when the value is valid" do
-
+        context 'when the value is valid' do
           before do
-            validator.validate_each(product, :sku, "12345")
+            validator.validate_each(product, :sku, '12345')
           end
 
-          it "adds no errors" do
+          it 'adds no errors' do
             expect(product.errors[:sku]).to be_empty
           end
         end
 
-        context "when the value is invalid" do
-
+        context 'when the value is invalid' do
           before do
-            validator.validate_each(product, :sku, "123456")
+            validator.validate_each(product, :sku, '123456')
           end
 
-          it "adds errors" do
-            expect(product.errors[:sku]).to eq(["is too long (maximum is 5 characters)"])
+          it 'adds errors' do
+            expect(product.errors[:sku]).to eq([ 'is too long (maximum is 5 characters)' ])
           end
         end
       end
 
-      context "when the underlying field name is validated" do
-
+      context 'when the underlying field name is validated' do
         let(:validator) do
-          described_class.new(attributes: [:stock_keeping_unit], in: 1..5)
+          described_class.new(attributes: [ :stock_keeping_unit ], in: 1..5)
         end
 
-        context "when the value is valid" do
-
+        context 'when the value is valid' do
           before do
-            validator.validate_each(product, :stock_keeping_unit, "12345")
+            validator.validate_each(product, :stock_keeping_unit, '12345')
           end
 
-          it "adds no errors" do
+          it 'adds no errors' do
             expect(product.errors[:stock_keeping_unit]).to be_empty
           end
         end
 
-        context "when the value is invalid" do
-
+        context 'when the value is invalid' do
           before do
-            validator.validate_each(product, :stock_keeping_unit, "123456")
+            validator.validate_each(product, :stock_keeping_unit, '123456')
           end
 
-          it "adds errors" do
-            expect(product.errors[:stock_keeping_unit]).to eq(["is too long (maximum is 5 characters)"])
+          it 'adds errors' do
+            expect(product.errors[:stock_keeping_unit]).to eq([ 'is too long (maximum is 5 characters)' ])
           end
         end
       end
 
-      context "when the field is localized" do
-
+      context 'when the field is localized' do
         let(:validator) do
-          described_class.new(attributes: [:tagline], in: 1..5)
+          described_class.new(attributes: [ :tagline ], in: 1..5)
         end
 
-        context "when the localized value is valid" do
-
+        context 'when the localized value is valid' do
           before do
-            validator.validate_each(product, :tagline, { "en" => "12345" })
+            validator.validate_each(product, :tagline, { 'en' => '12345' })
           end
 
-          it "adds no errors" do
+          it 'adds no errors' do
             expect(product.errors[:tagline]).to be_empty
           end
         end
 
-        context "when one of the localized values is invalid" do
-
+        context 'when one of the localized values is invalid' do
           before do
             validator.validate_each(
-                product,
-                :tagline, { "en" => "12345", "fr" => "123456" }
+              product,
+              :tagline, { 'en' => '12345', 'fr' => '123456' }
             )
           end
 
-          it "adds errors" do
-            expect(product.errors[:tagline]).to eq(["is too long (maximum is 5 characters)"])
+          it 'adds errors' do
+            expect(product.errors[:tagline]).to eq([ 'is too long (maximum is 5 characters)' ])
           end
         end
 
-        context "when the localized value is invalid" do
-
+        context 'when the localized value is invalid' do
           before do
-            validator.validate_each(product, :tagline, { "en" => "123456" })
+            validator.validate_each(product, :tagline, { 'en' => '123456' })
           end
 
-          it "adds errors" do
-            expect(product.errors[:tagline]).to eq(["is too long (maximum is 5 characters)"])
+          it 'adds errors' do
+            expect(product.errors[:tagline]).to eq([ 'is too long (maximum is 5 characters)' ])
           end
         end
       end
     end
   end
 
-  context "when validating an array" do
-
+  context 'when validating an array' do
     before do
       Person.validates :aliases, length: { minimum: 2, allow_blank: false }
     end
@@ -204,21 +182,19 @@ describe Mongoid::Validatable::LengthValidator do
       Person.reset_callbacks(:validate)
     end
 
-    context "when allow blank is false" do
-
+    context 'when allow blank is false' do
       let(:person) do
         Person.new
       end
 
-      context "when the array is empty" do
-
+      context 'when the array is empty' do
         before do
           person.array = []
           person.valid?
         end
 
-        it "adds the errors to the document" do
-          expect(person.errors[:aliases]).to_not be_empty
+        it 'adds the errors to the document' do
+          expect(person.errors[:aliases]).not_to be_empty
         end
       end
     end