mongoid 9.0.12 → 9.1.0

data/spec/mongoid/persistable/incrementable_spec.rb

@@ -1,46 +1,41 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Incrementable do
-
-  describe "#inc" do
-
-    context "when the document is a root document" do
-
-      shared_examples_for "an incrementable root document" do
-
-        it "increments a positive value" do
+  describe '#inc' do
+    context 'when the document is a root document' do
+      shared_examples_for 'an incrementable root document' do
+        it 'increments a positive value' do
           expect(person.age).to eq(15)
         end
 
-        it "decrements a negative value" do
+        it 'decrements a negative value' do
           expect(person.score).to eq(90)
         end
 
-        it "sets a nonexistent value" do
+        it 'sets a nonexistent value' do
           expect(person.inte).to eq(30)
         end
 
-        it "returns the self document" do
+        it 'returns the self document' do
           expect(inc).to eq(person)
         end
 
-        it "persists a positive inc" do
+        it 'persists a positive inc' do
           expect(person.reload.age).to eq(15)
         end
 
-        it "persists a negative inc" do
+        it 'persists a negative inc' do
           expect(person.reload.score).to eq(90)
         end
 
-        it "persists a nonexistent inc" do
+        it 'persists a nonexistent inc' do
           expect(person.reload.inte).to eq(30)
         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::Incrementable do
         Person.create!(age: 10, score: 100)
       end
 
-      context "when providing string fields" do
-
+      context 'when providing string fields' do
         let!(:inc) do
-          person.inc("age" => 5, "score" => -10, "inte" => 30)
+          person.inc('age' => 5, 'score' => -10, 'inte' => 30)
         end
 
-        it_behaves_like "an incrementable root document"
+        it_behaves_like 'an incrementable root document'
       end
 
-      context "when providing symbol fields" do
-
+      context 'when providing symbol fields' do
         let!(:inc) do
           person.inc(age: 5, score: -10, inte: 30)
         end
 
-        it_behaves_like "an incrementable root document"
+        it_behaves_like 'an incrementable root document'
       end
 
-      context "when providing big decimal values" do
-
+      context 'when providing big decimal values' do
         let(:five) do
-          BigDecimal("5.0")
+          BigDecimal('5.0')
         end
 
         let(:neg_ten) do
-          BigDecimal("-10.0")
+          BigDecimal('-10.0')
         end
 
         let(:thirty) do
-          BigDecimal("30.0")
+          BigDecimal('30.0')
         end
 
         let!(:inc) do
           person.inc(age: five, score: neg_ten, inte: thirty)
         end
 
-        it_behaves_like "an incrementable root document"
+        it_behaves_like 'an incrementable root document'
       end
     end
 
-    context "when the document is embedded" do
-
-      shared_examples_for "an incrementable embedded document" do
-
-        it "increments a positive value" do
+    context 'when the document is embedded' do
+      shared_examples_for 'an incrementable embedded document' do
+        it 'increments a positive value' do
           expect(address.number).to eq(15)
         end
 
-        it "decrements a negative value" do
+        it 'decrements a negative value' do
           expect(address.no).to eq(90)
         end
 
-        it "sets a nonexistent value" do
+        it 'sets a nonexistent value' do
           expect(address.house).to eq(30)
         end
 
-        it "returns the self document" do
+        it 'returns the self document' do
           expect(inc).to eq(address)
         end
 
-        it "persists a positive inc" do
+        it 'persists a positive inc' do
           expect(address.reload.number).to eq(15)
         end
 
-        it "persists a negative inc" do
+        it 'persists a negative inc' do
           expect(address.reload.no).to eq(90)
         end
 
-        it "persists a nonexistent inc" do
+        it 'persists a nonexistent inc' do
           expect(address.reload.house).to eq(30)
         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,62 +120,58 @@ describe Mongoid::Persistable::Incrementable 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!(:inc) do
-          address.inc("number" => 5, "no" => -10, "house" => 30)
+          address.inc('number' => 5, 'no' => -10, 'house' => 30)
         end
 
-        it_behaves_like "an incrementable embedded document"
+        it_behaves_like 'an incrementable embedded document'
       end
 
-      context "when providing symbol fields" do
-
+      context 'when providing symbol fields' do
         let!(:inc) do
           address.inc(number: 5, no: -10, house: 30)
         end
 
-        it_behaves_like "an incrementable embedded document"
+        it_behaves_like 'an incrementable embedded document'
       end
 
-      context "when providing big decimal values" do
-
+      context 'when providing big decimal values' do
         let(:five) do
-          BigDecimal("5.0")
+          BigDecimal('5.0')
         end
 
         let(:neg_ten) do
-          BigDecimal("-10.0")
+          BigDecimal('-10.0')
         end
 
         let(:thirty) do
-          BigDecimal("30.0")
+          BigDecimal('30.0')
         end
 
         let!(:inc) do
           address.inc(number: five, no: neg_ten, house: thirty)
         end
 
-        it_behaves_like "an incrementable embedded document"
+        it_behaves_like 'an incrementable embedded document'
       end
     end
 
-    context "when the document is embedded in another embedded document" do
-      shared_examples_for "an incrementable embedded document in another embedded document" do
-
-        it "increments a positive value" do
+    context 'when the document is embedded in another embedded document' do
+      shared_examples_for 'an incrementable embedded document in another embedded document' do
+        it 'increments a positive value' do
           expect(second_answer.position).to eq(2)
         end
 
-        it "persists a positive inc" do
+        it 'persists a positive inc' do
           expect(second_answer.reload.position).to eq(2)
         end
 
-        it "clears out dirty changes" do
-          expect(second_answer).to_not be_changed
+        it 'clears out dirty changes' do
+          expect(second_answer).not_to be_changed
         end
       end
 
@@ -205,54 +191,49 @@ describe Mongoid::Persistable::Incrementable do
         question.answers.create!(position: 1)
       end
 
-      context "when providing string fields" do
-
+      context 'when providing string fields' do
         let!(:inc) do
-          second_answer.inc("position" => 1)
+          second_answer.inc('position' => 1)
         end
 
-        it_behaves_like "an incrementable embedded document in another embedded document"
-
+        it_behaves_like 'an incrementable embedded document in another embedded document'
       end
 
-      context "when providing symbol fields" do
-
+      context 'when providing symbol fields' do
         let!(:inc) do
           second_answer.inc(position: 1)
         end
 
-        it_behaves_like "an incrementable embedded document in another embedded document"
+        it_behaves_like 'an incrementable embedded document in another 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 incremented fields" do
+      it 'marks a dirty change for the incremented fields' do
         person.atomically do
           person.inc age: 15, score: 2
-          expect(person.changes).to eq({"age" => [10, 25], "score" => [100, 102]})
+          expect(person.changes).to eq({ 'age' => [ 10, 25 ], 'score' => [ 100, 102 ] })
         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.inc(age: 15, score: 2)
           expect(person.age).to eq(25)
@@ -260,14 +241,14 @@ describe Mongoid::Persistable::Incrementable 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.inc(age: 15, score: 2)

data/spec/mongoid/persistable/logical_spec.rb

@@ -1,45 +1,40 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Logical do
-
-  describe "#bit" do
-
-    context "when the document is a root document" do
-
-      shared_examples_for "a logical root document" do
-
-        it "applies and operations" do
+  describe '#bit' do
+    context 'when the document is a root document' do
+      shared_examples_for 'a logical root document' do
+        it 'applies and operations' do
           expect(person.age).to eq(12)
         end
 
-        it "applies or operations" do
+        it 'applies or operations' do
           expect(person.score).to eq(61)
         end
 
-        it "applies mixed operations" do
+        it 'applies mixed operations' do
           expect(person.inte).to eq(14)
         end
 
-        it "returns self object" do
+        it 'returns self object' do
           expect(bit).to eq(person)
         end
 
-        it "resets dirty changes" do
-          expect(person).to_not be_changed
+        it 'resets dirty changes' do
+          expect(person).not_to be_changed
         end
 
-        it "persists and operations" do
+        it 'persists and operations' do
           expect(person.reload.age).to eq(12)
         end
 
-        it "persists or operations" do
+        it 'persists or operations' do
           expect(person.reload.score).to eq(61)
         end
 
-        it "persists mixed operations" do
+        it 'persists mixed operations' do
           expect(person.reload.inte).to eq(14)
         end
       end
@@ -48,64 +43,60 @@ describe Mongoid::Persistable::Logical do
         Person.create!(age: 60, score: 60, inte: 60)
       end
 
-      context "when provided string fields" do
-
+      context 'when provided string fields' do
         let!(:bit) do
           person.bit(
-            "age" => { "and" => 13 },
-            "score" => { "or" => 13 },
-            "inte" => { "and" => 13, "or" => 10 }
+            'age' => { 'and' => 13 },
+            'score' => { 'or' => 13 },
+            'inte' => { 'and' => 13, 'or' => 10 }
           )
         end
 
-        it_behaves_like "a logical root document"
+        it_behaves_like 'a logical root document'
       end
 
-      context "when provided symbol fields" do
-
+      context 'when provided symbol fields' do
         let!(:bit) do
           person.bit(
             age: { and: 13 }, score: { or: 13 }, inte: { and: 13, or: 10 }
           )
         end
 
-        it_behaves_like "a logical root document"
+        it_behaves_like 'a logical root document'
       end
     end
 
-    context "when the document is embedded" do
-
-      shared_examples_for "a logical embedded document" do
-
-        it "applies and operations" do
+    context 'when the document is embedded' do
+      shared_examples_for 'a logical embedded document' do
+        it 'applies and operations' do
           expect(address.number).to eq(12)
         end
 
-        it "applies or operations" do
+        it 'applies or operations' do
           expect(address.no).to eq(61)
         end
 
-        it "applies mixed operations" do
+        it 'applies mixed operations' do
           expect(address.house).to eq(14)
         end
 
-        it "returns the self object" do
+        it 'returns the self object' do
           expect(bit).to eq(address)
         end
 
-        it "resets dirty changes" do
-          expect(address).to_not be_changed
+        it 'resets dirty changes' do
+          expect(address).not_to be_changed
         end
 
-        it "persists and operations" do
+        it 'persists and operations' do
           expect(address.reload.number).to eq(12)
         end
 
-        it "persists or operations" do
+        it 'persists or operations' do
           expect(address.reload.no).to eq(61)
         end
 
-        it "persists mixed operations" do
+        it 'persists mixed operations' do
           expect(address.reload.house).to eq(14)
         end
       end
@@ -115,62 +106,58 @@ describe Mongoid::Persistable::Logical do
       end
 
       let(:address) do
-        person.addresses.create!(street: "t", number: 60, no: 60, house: 60)
+        person.addresses.create!(street: 't', number: 60, no: 60, house: 60)
       end
 
-      context "when provided string fields" do
-
+      context 'when provided string fields' do
         let!(:bit) do
           address.bit(
-            "number" => { "and" => 13 },
-            "no" => { "or" => 13 },
-            "house" => { "and" => 13, "or" => 10 }
+            'number' => { 'and' => 13 },
+            'no' => { 'or' => 13 },
+            'house' => { 'and' => 13, 'or' => 10 }
           )
         end
 
-        it_behaves_like "a logical embedded document"
+        it_behaves_like 'a logical embedded document'
       end
 
-      context "when provided symbol fields" do
-
+      context 'when provided symbol fields' do
         let!(:bit) do
           address.bit(
             number: { and: 13 }, no: { or: 13 }, house: { and: 13, or: 10 }
           )
         end
 
-        it_behaves_like "a logical embedded document"
+        it_behaves_like 'a logical 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 modified fields" do
+      it 'marks a dirty change for the modified fields' do
         person.atomically do
           person.bit age: { and: 6 }, score: { or: 122 }
-          expect(person.changes).to eq({"age" => [10, 2], "score" => [100, 126]})
+          expect(person.changes).to eq({ 'age' => [ 10, 2 ], 'score' => [ 100, 126 ] })
         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.bit(age: { and: 6 }, score: { or: 122 })
           expect(person.age).to eq(2)
@@ -178,14 +165,14 @@ describe Mongoid::Persistable::Logical 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.bit(age: { and: 6 }, score: { or: 122 })