mongoid 9.0.12 → 9.1.0

data/spec/mongoid/persistable/maxable_spec.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Maxable do
-
-  describe "#set_max" do
-
+  describe '#set_max' do
     shared_examples_for 'a max-able interface' do
-      context "when the document is a root document" do
-        let(:initial_name) { "Manhattan Transfer" }
+      context 'when the document is a root document' do
+        let(:initial_name) { 'Manhattan Transfer' }
         let(:initial_members) { 4 }
         let(:initial_founded) { Date.new(1972, 10, 1) }
 
@@ -17,34 +14,35 @@ describe Mongoid::Persistable::Maxable do
           Band.create!(
             name: initial_name,
             member_count: initial_members,
-            founded: initial_founded)
+            founded: initial_founded
+          )
         end
 
-        shared_examples_for "a max-able root document" do
+        shared_examples_for 'a max-able root document' do
           before do
             band.send(max_method,
-              name: given_name,
-              member_count: given_members,
-              founded: given_founded)
+                      name: given_name,
+                      member_count: given_members,
+                      founded: given_founded)
           end
 
           it 'sets the fields to larger of current vs. given' do
-            expect(band.reload.name).to be == [ initial_name, given_name ].max
-            expect(band.member_count).to be == [ initial_members, given_members ].max
-            expect(band.founded).to be == [ initial_founded, given_founded ].max
+            expect(band.reload.name).to eq [ initial_name, given_name ].max
+            expect(band.member_count).to eq [ initial_members, given_members ].max
+            expect(band.founded).to eq [ initial_founded, given_founded ].max
           end
 
-          it "resets dirty changes" do
-            expect(band).to_not be_changed
+          it 'resets dirty changes' do
+            expect(band).not_to be_changed
           end
         end
 
         context 'when given < initial' do
-          let(:given_name) { "A" }
+          let(:given_name) { 'A' }
           let(:given_members) { 3 }
           let(:given_founded) { Date.new(1970, 1, 1) }
 
-          it_behaves_like "a max-able root document"
+          it_behaves_like 'a max-able root document'
         end
 
         context 'when given == initial' do
@@ -52,20 +50,20 @@ describe Mongoid::Persistable::Maxable do
           let(:given_members) { initial_members }
           let(:given_founded) { initial_founded }
 
-          it_behaves_like "a max-able root document"
+          it_behaves_like 'a max-able root document'
         end
 
         context 'when given > initial' do
-          let(:given_name) { "Z" }
+          let(:given_name) { 'Z' }
           let(:given_members) { 10 }
           let(:given_founded) { Date.today }
 
-          it_behaves_like "a max-able root document"
+          it_behaves_like 'a max-able root document'
         end
       end
 
-      context "when the document is an embedded document" do
-        let(:initial_city) { "Manhattan" }
+      context 'when the document is an embedded document' do
+        let(:initial_city) { 'Manhattan' }
         let(:initial_number) { 100 }
         let(:initial_end_date) { Date.today }
 
@@ -74,34 +72,35 @@ describe Mongoid::Persistable::Maxable do
           person.addresses.create!(
             city: initial_city,
             number: initial_number,
-            end_date: initial_end_date)
+            end_date: initial_end_date
+          )
         end
 
-        shared_examples_for "a max-able embedded document" do
+        shared_examples_for 'a max-able embedded document' do
           before do
             address.send(max_method,
-              city: given_city,
-              number: given_number,
-              end_date: given_end_date)
+                         city: given_city,
+                         number: given_number,
+                         end_date: given_end_date)
           end
 
           it 'sets the fields to smaller of current vs. given' do
-            expect(address.reload.city).to be == [ initial_city, given_city ].max
-            expect(address.number).to be == [ initial_number, given_number ].max
-            expect(address.end_date).to be == [ initial_end_date, given_end_date ].max
+            expect(address.reload.city).to eq [ initial_city, given_city ].max
+            expect(address.number).to eq [ initial_number, given_number ].max
+            expect(address.end_date).to eq [ initial_end_date, given_end_date ].max
           end
 
-          it "resets dirty changes" do
-            expect(address).to_not be_changed
+          it 'resets dirty changes' do
+            expect(address).not_to be_changed
           end
         end
 
         context 'when given < initial' do
-          let(:given_city) { "A" }
+          let(:given_city) { 'A' }
           let(:given_number) { 10 }
           let(:given_end_date) { 5.days.ago.to_date }
 
-          it_behaves_like "a max-able embedded document"
+          it_behaves_like 'a max-able embedded document'
         end
 
         context 'when given == initial' do
@@ -109,26 +108,26 @@ describe Mongoid::Persistable::Maxable do
           let(:given_number) { initial_number }
           let(:given_end_date) { initial_end_date }
 
-          it_behaves_like "a max-able embedded document"
+          it_behaves_like 'a max-able embedded document'
         end
 
         context 'when given > initial' do
-          let(:given_city) { "Z" }
+          let(:given_city) { 'Z' }
           let(:given_number) { 1000 }
           let(:given_end_date) { 5.days.from_now.to_date }
 
-          it_behaves_like "a max-able embedded document"
+          it_behaves_like 'a max-able embedded document'
         end
       end
 
-      context "when executing atomically" do
-        let(:band) { Band.create!(member_count: 10, name: "Manhattan Transfer") }
+      context 'when executing atomically' do
+        let(:band) { Band.create!(member_count: 10, name: 'Manhattan Transfer') }
 
-        it "marks a dirty change for the modified fields" do
+        it 'marks a dirty change for the modified fields' do
           band.atomically do
-            band.send(max_method, member_count: 15, name: "Manhattan Transfer")
+            band.send(max_method, member_count: 15, name: 'Manhattan Transfer')
             expect(band.changes)
-              .to be == { "member_count" => [10, 15] }
+              .to eq({ 'member_count' => [ 10, 15 ] })
           end
         end
       end
@@ -136,11 +135,13 @@ describe Mongoid::Persistable::Maxable do
 
     context 'as itself' do
       let(:max_method) { :set_max }
+
       it_behaves_like 'a max-able interface'
     end
 
     context 'as #clamp_lower_bound' do
       let(:max_method) { :clamp_lower_bound }
+
       it_behaves_like 'a max-able interface'
     end
   end

data/spec/mongoid/persistable/minable_spec.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Minable do
-
-  describe "#set_min" do
-
+  describe '#set_min' do
     shared_examples_for 'a min-able interface' do
-      context "when the document is a root document" do
-        let(:initial_name) { "Manhattan Transfer" }
+      context 'when the document is a root document' do
+        let(:initial_name) { 'Manhattan Transfer' }
         let(:initial_members) { 4 }
         let(:initial_founded) { Date.new(1972, 10, 1) }
 
@@ -17,34 +14,35 @@ describe Mongoid::Persistable::Minable do
           Band.create!(
             name: initial_name,
             member_count: initial_members,
-            founded: initial_founded)
+            founded: initial_founded
+          )
         end
 
-        shared_examples_for "a min-able root document" do
+        shared_examples_for 'a min-able root document' do
           before do
             band.send(min_method,
-              name: given_name,
-              member_count: given_members,
-              founded: given_founded)
+                      name: given_name,
+                      member_count: given_members,
+                      founded: given_founded)
           end
 
           it 'sets the fields to smaller of current vs. given' do
-            expect(band.reload.name).to be == [ initial_name, given_name ].min
-            expect(band.member_count).to be == [ initial_members, given_members ].min
-            expect(band.founded).to be == [ initial_founded, given_founded ].min
+            expect(band.reload.name).to eq [ initial_name, given_name ].min
+            expect(band.member_count).to eq [ initial_members, given_members ].min
+            expect(band.founded).to eq [ initial_founded, given_founded ].min
           end
 
-          it "resets dirty changes" do
-            expect(band).to_not be_changed
+          it 'resets dirty changes' do
+            expect(band).not_to be_changed
           end
         end
 
         context 'when given < initial' do
-          let(:given_name) { "A" }
+          let(:given_name) { 'A' }
           let(:given_members) { 3 }
           let(:given_founded) { Date.new(1970, 1, 1) }
 
-          it_behaves_like "a min-able root document"
+          it_behaves_like 'a min-able root document'
         end
 
         context 'when given == initial' do
@@ -52,20 +50,20 @@ describe Mongoid::Persistable::Minable do
           let(:given_members) { initial_members }
           let(:given_founded) { initial_founded }
 
-          it_behaves_like "a min-able root document"
+          it_behaves_like 'a min-able root document'
         end
 
         context 'when given > initial' do
-          let(:given_name) { "Z" }
+          let(:given_name) { 'Z' }
           let(:given_members) { 10 }
           let(:given_founded) { Date.today }
 
-          it_behaves_like "a min-able root document"
+          it_behaves_like 'a min-able root document'
         end
       end
 
-      context "when the document is an embedded document" do
-        let(:initial_city) { "Manhattan" }
+      context 'when the document is an embedded document' do
+        let(:initial_city) { 'Manhattan' }
         let(:initial_number) { 100 }
         let(:initial_end_date) { Date.today }
 
@@ -74,34 +72,35 @@ describe Mongoid::Persistable::Minable do
           person.addresses.create!(
             city: initial_city,
             number: initial_number,
-            end_date: initial_end_date)
+            end_date: initial_end_date
+          )
         end
 
-        shared_examples_for "a min-able embedded document" do
+        shared_examples_for 'a min-able embedded document' do
           before do
             address.send(min_method,
-              city: given_city,
-              number: given_number,
-              end_date: given_end_date)
+                         city: given_city,
+                         number: given_number,
+                         end_date: given_end_date)
           end
 
           it 'sets the fields to smaller of current vs. given' do
-            expect(address.reload.city).to be == [ initial_city, given_city ].min
-            expect(address.number).to be == [ initial_number, given_number ].min
-            expect(address.end_date).to be == [ initial_end_date, given_end_date ].min
+            expect(address.reload.city).to eq [ initial_city, given_city ].min
+            expect(address.number).to eq [ initial_number, given_number ].min
+            expect(address.end_date).to eq [ initial_end_date, given_end_date ].min
           end
 
-          it "resets dirty changes" do
-            expect(address).to_not be_changed
+          it 'resets dirty changes' do
+            expect(address).not_to be_changed
           end
         end
 
         context 'when given < initial' do
-          let(:given_city) { "A" }
+          let(:given_city) { 'A' }
           let(:given_number) { 10 }
           let(:given_end_date) { 5.days.ago.to_date }
 
-          it_behaves_like "a min-able embedded document"
+          it_behaves_like 'a min-able embedded document'
         end
 
         context 'when given == initial' do
@@ -109,26 +108,26 @@ describe Mongoid::Persistable::Minable do
           let(:given_number) { initial_number }
           let(:given_end_date) { initial_end_date }
 
-          it_behaves_like "a min-able embedded document"
+          it_behaves_like 'a min-able embedded document'
         end
 
         context 'when given > initial' do
-          let(:given_city) { "Z" }
+          let(:given_city) { 'Z' }
           let(:given_number) { 1000 }
           let(:given_end_date) { 5.days.from_now.to_date }
 
-          it_behaves_like "a min-able embedded document"
+          it_behaves_like 'a min-able embedded document'
         end
       end
 
-      context "when executing atomically" do
-        let(:band) { Band.create!(member_count: 10, name: "Manhattan Transfer") }
+      context 'when executing atomically' do
+        let(:band) { Band.create!(member_count: 10, name: 'Manhattan Transfer') }
 
-        it "marks a dirty change for the modified fields" do
+        it 'marks a dirty change for the modified fields' do
           band.atomically do
-            band.send(min_method, member_count: 5, name: "Manhattan Transfer")
+            band.send(min_method, member_count: 5, name: 'Manhattan Transfer')
             expect(band.changes)
-              .to be == { "member_count" => [10, 5] }
+              .to eq({ 'member_count' => [ 10, 5 ] })
           end
         end
       end
@@ -136,11 +135,13 @@ describe Mongoid::Persistable::Minable do
 
     context 'as itself' do
       let(:min_method) { :set_min }
+
       it_behaves_like 'a min-able interface'
     end
 
     context 'as #clamp_upper_bound' do
       let(:min_method) { :clamp_upper_bound }
+
       it_behaves_like 'a min-able interface'
     end
   end

data/spec/mongoid/persistable/multipliable_spec.rb

@@ -1,46 +1,41 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Multipliable do
-
-  describe "#mul" do
-
-    context "when the document is a root document" do
-
-      shared_examples_for "a multipliable root document" do
-
-        it "multiplies a positive value" do
+  describe '#mul' do
+    context 'when the document is a root document' do
+      shared_examples_for 'a multipliable root document' do
+        it 'multiplies a positive value' do
           expect(person.age).to eq(50)
         end
 
-        it "multiplies a negative value" do
+        it 'multiplies a negative value' do
           expect(person.score).to eq(-500)
         end
 
-        it "multiplies a nonexistent value" do
+        it 'multiplies a nonexistent value' do
           expect(person.inte).to eq(0)
         end
 
-        it "returns the self document" do
+        it 'returns the self document' do
           expect(op).to eq(person)
         end
 
-        it "persists a positive mul" do
+        it 'persists a positive mul' do
           expect(person.reload.age).to eq(50)
         end
 
-        it "persists a negative mul" do
+        it 'persists a negative mul' do
           expect(person.reload.score).to eq(-500)
         end
 
-        it "persists a nonexistent mul" do
+        it 'persists a nonexistent mul' do
           expect(person.reload.inte).to eq(0)
         end
 
-        it "clears out dirty changes" do
-          expect(person).to_not be_changed
+        it 'clears out dirty changes' do
+          expect(person).not_to be_changed
         end
       end
 
@@ -48,80 +43,75 @@ describe Mongoid::Persistable::Multipliable do
         Person.create!(age: 10, score: 100)
       end
 
-      context "when providing string fields" do
-
+      context 'when providing string fields' do
         let!(:op) do
-          person.mul("age" => 5, "score" => -5, "inte" => 30)
+          person.mul('age' => 5, 'score' => -5, 'inte' => 30)
         end
 
-        it_behaves_like "a multipliable root document"
+        it_behaves_like 'a multipliable root document'
       end
 
-      context "when providing symbol fields" do
-
+      context 'when providing symbol fields' do
         let!(:op) do
           person.mul(age: 5, score: -5, inte: 30)
         end
 
-        it_behaves_like "a multipliable root document"
+        it_behaves_like 'a multipliable root document'
       end
 
-      context "when providing big decimal values" do
-
+      context 'when providing big decimal values' do
         let(:positive) do
-          BigDecimal("5.0")
+          BigDecimal('5.0')
         end
 
         let(:negative) do
-          BigDecimal("-5.0")
+          BigDecimal('-5.0')
         end
 
         let(:dynamic) do
-          BigDecimal("30.0")
+          BigDecimal('30.0')
         end
 
         let!(:op) do
           person.mul(age: positive, score: negative, inte: dynamic)
         end
 
-        it_behaves_like "a multipliable root document"
+        it_behaves_like 'a multipliable root document'
       end
     end
 
-    context "when the document is embedded" do
-
-      shared_examples_for "a multipliable embedded document" do
-
-        it "multiplies a positive value" do
+    context 'when the document is embedded' do
+      shared_examples_for 'a multipliable embedded document' do
+        it 'multiplies a positive value' do
           expect(address.number).to eq(50)
         end
 
-        it "multiplies a negative value" do
+        it 'multiplies a negative value' do
           expect(address.no).to eq(-500)
         end
 
-        it "multiplies a nonexistent value" do
+        it 'multiplies a nonexistent value' do
           expect(address.house).to eq(0)
         end
 
-        it "returns the self document" do
+        it 'returns the self document' do
           expect(op).to eq(address)
         end
 
-        it "persists a positive mul" do
+        it 'persists a positive mul' do
           expect(address.reload.number).to eq(50)
         end
 
-        it "persists a negative mul" do
+        it 'persists a negative mul' do
           expect(address.reload.no).to eq(-500)
         end
 
-        it "persists a nonexistent mul" do
+        it 'persists a nonexistent mul' do
           expect(address.reload.house).to eq(0)
         end
 
-        it "clears out dirty changes" do
-          expect(address).to_not be_changed
+        it 'clears out dirty changes' do
+          expect(address).not_to be_changed
         end
       end
 
@@ -130,77 +120,72 @@ describe Mongoid::Persistable::Multipliable do
       end
 
       let(:address) do
-        person.addresses.create!(street: "test", number: 10, no: 100)
+        person.addresses.create!(street: 'test', number: 10, no: 100)
       end
 
-      context "when providing string fields" do
-
+      context 'when providing string fields' do
         let!(:op) do
-          address.mul("number" => 5, "no" => -5, "house" => 30)
+          address.mul('number' => 5, 'no' => -5, 'house' => 30)
         end
 
-        it_behaves_like "a multipliable embedded document"
+        it_behaves_like 'a multipliable embedded document'
       end
 
-      context "when providing symbol fields" do
-
+      context 'when providing symbol fields' do
         let!(:op) do
           address.mul(number: 5, no: -5, house: 30)
         end
 
-        it_behaves_like "a multipliable embedded document"
+        it_behaves_like 'a multipliable embedded document'
       end
 
-      context "when providing big decimal values" do
-
+      context 'when providing big decimal values' do
         let(:positive) do
-          BigDecimal("5.0")
+          BigDecimal('5.0')
         end
 
         let(:negative) do
-          BigDecimal("-5.0")
+          BigDecimal('-5.0')
         end
 
         let(:dynamic) do
-          BigDecimal("30.0")
+          BigDecimal('30.0')
         end
 
         let!(:op) do
           address.mul(number: positive, no: negative, house: dynamic)
         end
 
-        it_behaves_like "a multipliable embedded document"
+        it_behaves_like 'a multipliable embedded document'
       end
     end
 
-    context "when executing atomically" do
-
+    context 'when executing atomically' do
       let(:person) do
         Person.create!(age: 10, score: 100)
       end
 
-      it "marks a dirty change for the multiplied fields" do
+      it 'marks a dirty change for the multiplied fields' do
         person.atomically do
           person.mul age: 15, score: 2
-          expect(person.changes).to eq({"age" => [10, 150], "score" => [100, 200]})
+          expect(person.changes).to eq({ 'age' => [ 10, 150 ], 'score' => [ 100, 200 ] })
         end
       end
     end
 
-    context "when executing on a readonly document" do
-
+    context 'when executing on a readonly document' do
       let(:person) do
         Person.create!(age: 10, score: 100)
       end
 
-      context "when legacy_readonly is true" do
+      context 'when legacy_readonly is true' do
         config_override :legacy_readonly, true
 
         before do
-          person.__selected_fields = { "age" => 1, "score" => 1 }
+          person.__selected_fields = { 'age' => 1, 'score' => 1 }
         end
 
-        it "persists the changes" do
+        it 'persists the changes' do
           expect(person).to be_readonly
           person.mul(age: 15, score: 2)
           expect(person.age).to eq(150)
@@ -208,14 +193,14 @@ describe Mongoid::Persistable::Multipliable do
         end
       end
 
-      context "when legacy_readonly is false" do
+      context 'when legacy_readonly is false' do
         config_override :legacy_readonly, false
 
         before do
           person.readonly!
         end
 
-        it "raises a ReadonlyDocument error" do
+        it 'raises a ReadonlyDocument error' do
           expect(person).to be_readonly
           expect do
             person.mul(age: 15, score: 2)