mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/reflections_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Reflections do
-
   class TestClass
     include Mongoid::Document
   end
@@ -17,75 +15,67 @@ describe Mongoid::Association::Reflections do
     klass.relations.clear
   end
 
-  describe ".reflect_on_association" do
-
+  describe '.reflect_on_association' do
     before do
       klass.embeds_many(:addresses)
     end
 
-    context "when the name does not exist" do
-
+    context 'when the name does not exist' do
       let(:relation) do
         klass.reflect_on_association(:nonexistent)
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(relation).to be_nil
       end
     end
   end
 
-  describe ".reflect_on_all_associations" do
-
-    context "when relations exist for the macros" do
-
+  describe '.reflect_on_all_associations' do
+    context 'when relations exist for the macros' do
       before do
         klass.embeds_one(:name)
         klass.embeds_many(:addresses)
         klass.has_one(:user)
       end
 
-      context "when passing multiple arguments" do
-
+      context 'when passing multiple arguments' do
         let(:relations) do
           klass.reflect_on_all_associations(:embeds_one, :has_one)
         end
 
-        it "returns an array of the relations" do
+        it 'returns an array of the relations' do
           expect(relations.size).to eq(2)
         end
       end
 
-      context "when passing a single argument" do
-
+      context 'when passing a single argument' do
         let(:relations) do
           klass.reflect_on_all_associations(:embeds_one)
         end
 
-        it "returns an array of the relations" do
+        it 'returns an array of the relations' do
           expect(relations.size).to eq(1)
         end
       end
 
-      context "when no argument supplied" do
-
+      context 'when no argument supplied' do
         let(:relations) do
           klass.reflect_on_all_associations
         end
 
-        it "returns an array of all relations" do
+        it 'returns an array of all relations' do
           expect(relations.size).to eq(3)
         end
       end
     end
 
-    context "when no relations exist for the macros" do
-
+    context 'when no relations exist for the macros' do
       let(:relations) do
         klass.reflect_on_all_associations(:embeds_one)
       end
 
-      it "returns an empty array" do
+      it 'returns an empty array' do
         expect(relations).to be_empty
       end
     end

data/spec/mongoid/association/syncable_spec.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
-describe "Syncable Association" do
+describe 'Syncable Association' do
   config_override :raise_not_found_error, true
 
   before(:all) do
-    Person._synced(Person.relations["preferences"])
+    Person._synced(Person.relations['preferences'])
     Person.has_and_belongs_to_many :preferences
     Preference.has_and_belongs_to_many :people
   end
@@ -18,10 +17,10 @@ describe "Syncable Association" do
   end
 
   describe 'Model loading' do
-
     let(:model_synced) do
       class TestModel
         include Mongoid::Document
+
         field :_synced
       end
     end
@@ -29,6 +28,7 @@ describe "Syncable Association" do
     let(:model_synced?) do
       class TestModel
         include Mongoid::Document
+
         field :_synced?
       end
     end
@@ -36,6 +36,7 @@ describe "Syncable Association" do
     let(:model_syncable?) do
       class TestModel
         include Mongoid::Document
+
         field :_syncable?
       end
     end
@@ -44,27 +45,26 @@ describe "Syncable Association" do
       Object.send(:remove_const, :TestModel)
     end
 
-    it 'prohibits the use of :_sycned as an attribute' do
-      expect {
+    it 'prohibits the use of :_synced as an attribute' do
+      expect do
         model_synced
-      }.to raise_exception(Mongoid::Errors::InvalidField)
+      end.to raise_exception(Mongoid::Errors::InvalidField)
     end
 
     it 'prohibits the use of :_synced? as an attribute' do
-      expect {
+      expect do
         model_synced?
-      }.to raise_exception(Mongoid::Errors::InvalidField)
+      end.to raise_exception(Mongoid::Errors::InvalidField)
     end
 
     it 'prohibits the use of :_syncable? as an attribute' do
-      expect {
+      expect do
         model_syncable?
-      }.to raise_exception(Mongoid::Errors::InvalidField)
+      end.to raise_exception(Mongoid::Errors::InvalidField)
     end
   end
 
-  describe ".update_inverse_keys" do
-
+  describe '.update_inverse_keys' do
     let(:agent) do
       Agent.create!
     end
@@ -77,61 +77,57 @@ describe "Syncable Association" do
       Person.create!
     end
 
-    context "when an unpersisted account is created" do
-
+    context 'when an unpersisted account is created' do
       let(:account) do
         Account.new do |a|
-          a.name = "testing"
+          a.name = 'testing'
           a.creator = user
           a.person = person
         end
       end
 
-      it "has persisted :agent" do
+      it 'has persisted :agent' do
         expect(agent.persisted?).to be true
       end
 
-      it "has persisted :user" do
+      it 'has persisted :user' do
         expect(user.persisted?).to be true
       end
 
-      it "has persisted :person" do
+      it 'has persisted :person' do
         expect(person.persisted?).to be true
       end
 
-      it "does not have persisted :account" do
+      it 'does not have persisted :account' do
         expect(account.persisted?).to be false
       end
 
-      it "has instantiated a .valid? :account" do
+      it 'has instantiated a .valid? :account' do
         account.valid?
         expect(account.valid?).to be true
       end
 
-      context "and is Persisted" do
-
-        it "is able to :save" do
+      context 'and is Persisted' do
+        it 'is able to :save' do
           expect(account.save!).to be true
         end
       end
 
-      context "check for existing Agent, then Persisted" do
-
+      context 'check for existing Agent, then Persisted' do
         before do
           account.agents.where(_id: agent.id).exists?
         end
 
-        it "is able to :save" do
+        it 'is able to :save' do
           expect(account.save!).to be true
         end
       end
     end
   end
 
-  context "when the inverse of is nil" do
-
+  context 'when the inverse of is nil' do
     let(:preference) do
-      Preference.new(name: "test")
+      Preference.new(name: 'test')
     end
 
     let(:article) do
@@ -142,41 +138,39 @@ describe "Syncable Association" do
       article.preferences << preference
     end
 
-    it "does not attempt synchronization" do
-      expect { article.save! }.to_not raise_error
+    it 'does not attempt synchronization' do
+      expect { article.save! }.not_to raise_error
     end
 
-    it "sets the one side of the relation" do
+    it 'sets the one side of the relation' do
       expect(article.preferences).to eq([ preference ])
     end
   end
 
-  context "when first setting by the relation itself" do
-
+  context 'when first setting by the relation itself' do
     let!(:person) do
       Person.create!
     end
 
     let!(:one) do
-      Preference.create!(name: "one")
+      Preference.create!(name: 'one')
     end
 
     before do
       person.preferences << one
     end
 
-    it "sets the inverse foreign key" do
+    it 'sets the inverse foreign key' do
       expect(one.person_ids).to eq([ person.id ])
     end
 
-    it "resets the synced flag" do
-      expect(person._synced["preference_ids"]).to be false
+    it 'resets the synced flag' do
+      expect(person._synced['preference_ids']).to be false
     end
 
-    context "when subsequently setting with keys" do
-
+    context 'when subsequently setting with keys' do
       let!(:two) do
-        Preference.create!(name: "two")
+        Preference.create!(name: 'two')
       end
 
       before do
@@ -184,73 +178,69 @@ describe "Syncable Association" do
         person.save!
       end
 
-      it "sets the inverse foreign key" do
+      it 'sets the inverse foreign key' do
         expect(two.reload.person_ids).to eq([ person.id ])
       end
     end
   end
 
-  context "when setting new ids" do
-
+  context 'when setting new ids' do
     let!(:person) do
       Person.create!
     end
 
     let!(:one) do
-      Preference.create!(name: "one")
+      Preference.create!(name: 'one')
     end
 
     let!(:two) do
-      Preference.create!(name: "two")
+      Preference.create!(name: 'two')
     end
 
     before do
       person.preference_ids = [ one.id, two.id ]
     end
 
-    it "sets the foreign_key" do
+    it 'sets the foreign_key' do
       expect(person.preference_ids).to eq([ one.id, two.id ])
     end
 
-    it "does not set the first inverse key" do
+    it 'does not set the first inverse key' do
       expect(one.reload.person_ids).to be_empty
     end
 
-    it "does not set the second inverse key" do
+    it 'does not set the second inverse key' do
       expect(two.reload.person_ids).to be_empty
     end
 
-    context "when saving the base" do
-
-      context "when validation passes" do
-
+    context 'when saving the base' do
+      context 'when validation passes' do
         before do
           person.save!
         end
 
-        it "persists the foreign_key" do
+        it 'persists the foreign_key' do
           expect(person.reload.preference_ids).to eq([ one.id, two.id ])
         end
 
-        it "sets the first inverse key" do
+        it 'sets the first inverse key' do
           expect(one.reload.person_ids).to eq([ person.id ])
         end
 
-        it "sets the second inverse key" do
+        it 'sets the second inverse key' do
           expect(two.reload.person_ids).to eq([ person.id ])
         end
       end
     end
   end
 
-  context "when replacing ids" do
-
+  context 'when replacing ids' do
     let!(:one) do
-      Preference.create!(name: "one")
+      Preference.create!(name: 'one')
     end
 
     let!(:two) do
-      Preference.create!(name: "two")
+      Preference.create!(name: 'two')
     end
 
     let!(:person) do
@@ -258,64 +248,61 @@ describe "Syncable Association" do
     end
 
     let!(:three) do
-      Preference.create!(name: "three")
+      Preference.create!(name: 'three')
     end
 
     before do
       person.preference_ids = [ three.id ]
     end
 
-    it "sets the foreign_key" do
+    it 'sets the foreign_key' do
       expect(person.preference_ids).to eq([ three.id ])
     end
 
-    it "does not remove the first inverse key" do
+    it 'does not remove the first inverse key' do
       expect(one.reload.person_ids).to eq([ person.id ])
     end
 
-    it "does not remove the second inverse key" do
+    it 'does not remove the second inverse key' do
       expect(two.reload.person_ids).to eq([ person.id ])
     end
 
-    it "does not set the third inverse key" do
+    it 'does not set the third inverse key' do
       expect(three.reload.person_ids).to be_empty
     end
 
-    context "when saving the base" do
-
-      context "when validation passes" do
-
+    context 'when saving the base' do
+      context 'when validation passes' do
         before do
           person.save!
         end
 
-        it "persists the foreign_key" do
+        it 'persists the foreign_key' do
           expect(person.reload.preference_ids).to eq([ three.id ])
         end
 
-        it "removes the first inverse key" do
+        it 'removes the first inverse key' do
           expect(one.reload.person_ids).to be_empty
         end
 
-        it "removes the second inverse key" do
+        it 'removes the second inverse key' do
           expect(two.reload.person_ids).to be_empty
         end
 
-        it "sets the third inverse key" do
+        it 'sets the third inverse key' do
           expect(three.reload.person_ids).to eq([ person.id ])
         end
       end
     end
   end
 
-  context "when setting ids to empty" do
-
+  context 'when setting ids to empty' do
     let!(:one) do
-      Preference.create!(name: "one")
+      Preference.create!(name: 'one')
     end
 
     let!(:two) do
-      Preference.create!(name: "two")
+      Preference.create!(name: 'two')
     end
 
     let!(:person) do
@@ -326,49 +313,46 @@ describe "Syncable Association" do
       person.preference_ids = []
     end
 
-    it "sets the foreign_key" do
+    it 'sets the foreign_key' do
       expect(person.preference_ids).to be_empty
     end
 
-    it "does not remove the first inverse key" do
+    it 'does not remove the first inverse key' do
       expect(one.reload.person_ids).to eq([ person.id ])
     end
 
-    it "does not remove the second inverse key" do
+    it 'does not remove the second inverse key' do
       expect(two.reload.person_ids).to eq([ person.id ])
     end
 
-    context "when saving the base" do
-
-      context "when validation passes" do
-
+    context 'when saving the base' do
+      context 'when validation passes' do
         before do
           person.save!
         end
 
-        it "persists the foreign_key" do
+        it 'persists the foreign_key' do
           expect(person.reload.preference_ids).to be_empty
         end
 
-        it "removes the first inverse key" do
+        it 'removes the first inverse key' do
           expect(one.reload.person_ids).to be_empty
         end
 
-        it "removes the second inverse key" do
+        it 'removes the second inverse key' do
           expect(two.reload.person_ids).to be_empty
         end
       end
     end
   end
 
-  context "when setting ids to nil" do
-
+  context 'when setting ids to nil' do
     let!(:one) do
-      Preference.create!(name: "one")
+      Preference.create!(name: 'one')
     end
 
     let!(:two) do
-      Preference.create!(name: "two")
+      Preference.create!(name: 'two')
     end
 
     let!(:person) do
@@ -379,84 +363,78 @@ describe "Syncable Association" do
       person.preference_ids = nil
     end
 
-    it "sets the foreign_key" do
+    it 'sets the foreign_key' do
       expect(person.preference_ids).to be_empty
     end
 
-    it "does not remove the first inverse key" do
+    it 'does not remove the first inverse key' do
       expect(one.reload.person_ids).to eq([ person.id ])
     end
 
-    it "does not remove the second inverse key" do
+    it 'does not remove the second inverse key' do
       expect(two.reload.person_ids).to eq([ person.id ])
     end
 
-    context "when saving the base" do
-
-      context "when validation passes" do
-
+    context 'when saving the base' do
+      context 'when validation passes' do
         before do
           person.save!
         end
 
-        it "persists the foreign_key" do
+        it 'persists the foreign_key' do
           expect(person.reload.preference_ids).to be_empty
         end
 
-        it "removes the first inverse key" do
+        it 'removes the first inverse key' do
           expect(one.reload.person_ids).to be_empty
         end
 
-        it "removes the second inverse key" do
+        it 'removes the second inverse key' do
           expect(two.reload.person_ids).to be_empty
         end
       end
     end
   end
 
-  context "when destroying" do
-
+  context 'when destroying' do
     let!(:one) do
-      Preference.create!(name: "one")
+      Preference.create!(name: 'one')
     end
 
     let!(:two) do
-      Preference.create!(name: "two")
+      Preference.create!(name: 'two')
     end
 
     let!(:person) do
       Person.create!(preferences: [ one, two ])
     end
 
-    context "when destroying the parent" do
-
+    context 'when destroying the parent' do
       before do
         person.destroy
       end
 
-      it "removes the first inverse key" do
+      it 'removes the first inverse key' do
         expect(one.reload.person_ids).to be_empty
       end
 
-      it "removes the second inverse key" do
+      it 'removes the second inverse key' do
         expect(two.reload.person_ids).to be_empty
       end
     end
 
-    context "when destroying the child" do
-
+    context 'when destroying the child' do
       before do
         one.destroy
       end
 
-      it "removes the inverse key" do
+      it 'removes the inverse key' do
         expect(person.reload.preference_ids).to eq([ two.id ])
       end
     end
   end
 
-  context "when appending an existing document to a new one" do
-
+  context 'when appending an existing document to a new one' do
     let!(:persisted) do
       Tag.create!
     end
@@ -470,19 +448,18 @@ describe "Syncable Association" do
       article.save!
     end
 
-    it "persists the foreign key on the inverse" do
+    it 'persists the foreign key on the inverse' do
       expect(persisted.article_ids).to eq([ article.id ])
     end
 
-    it "persists the inverse relation" do
+    it 'persists the inverse relation' do
       expect(persisted.articles).to eq([ article ])
     end
   end
 
-  context "when the document has an ordering default scope" do
-
+  context 'when the document has an ordering default scope' do
     let!(:dog) do
-      Dog.create!(name: "Fido")
+      Dog.create!(name: 'Fido')
     end
 
     let!(:breed) do
@@ -493,12 +470,12 @@ describe "Syncable Association" do
       breed.save!
     end
 
-    it "adds the id to the inverse relation" do
+    it 'adds the id to the inverse relation' do
       expect(dog.reload.breed_ids).to eq([ breed.id ])
     end
   end
 
-  context "when setting one document on unpersisted HABTM association" do
+  context 'when setting one document on unpersisted HABTM association' do
     let!(:dog) { Dog.create! }
     let!(:breed) { Breed.new }
 
@@ -507,8 +484,8 @@ describe "Syncable Association" do
       breed.save!
     end
 
-    it "sets the foreign key on the other side" do
-      expect(dog.reload.breed_ids).to eq([breed._id])
+    it 'sets the foreign key on the other side' do
+      expect(dog.reload.breed_ids).to eq([ breed._id ])
     end
   end
 end