mongoid 9.0.11 → 9.1.1

data/spec/mongoid/association/referenced/has_and_belongs_to_many/binding_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Referenced::HasAndBelongsToMany::Binding do
-
   let(:person) do
     Person.new
   end
@@ -18,17 +16,15 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Binding do
   end
 
   let(:association) do
-    Person.relations["preferences"]
+    Person.relations['preferences']
   end
 
-  describe "#bind_one" do
-
+  describe '#bind_one' do
     let(:binding) do
       described_class.new(person, target, association)
     end
 
-    context "when the document is bindable" do
-
+    context 'when the document is bindable' do
       let(:preference_two) do
         Preference.new
       end
@@ -37,110 +33,102 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Binding do
         binding.bind_one(preference_two)
       end
 
-      it "sets the inverse foreign key" do
+      it 'sets the inverse foreign key' do
         expect(preference_two.person_ids).to eq([ person.id ])
       end
 
-      it "passes the binding options through to the inverse" do
-        expect(person).to receive(:save).never
+      it 'passes the binding options through to the inverse' do
+        expect(person).not_to receive(:save)
       end
 
-      it "syncs the base" do
-        expect(person._synced?("preference_ids")).to be(true)
+      it 'syncs the base' do
+        expect(person._synced?('preference_ids')).to be(true)
       end
 
-      it "syncs the inverse" do
-        expect(preference_two._synced?("person_ids")).to be(true)
+      it 'syncs the inverse' do
+        expect(preference_two._synced?('person_ids')).to be(true)
       end
     end
 
-    context "when ensuring minimal saves" do
-
+    context 'when ensuring minimal saves' do
       let(:preference_two) do
         Preference.new.tap do |pref|
           pref.new_record = false
         end
       end
 
-      it "does not save the parent on bind" do
-        expect(person).to receive(:save).never
+      it 'does not save the parent on bind' do
+        expect(person).not_to receive(:save)
         binding.bind_one(preference_two)
       end
     end
 
-    context "when the document is not bindable" do
-
-      it "does nothing" do
-        expect(person.preferences).to receive(:<<).never
+    context 'when the document is not bindable' do
+      it 'does nothing' do
+        expect(person.preferences).not_to receive(:<<)
         binding.bind_one(preference)
       end
     end
   end
 
-  describe "#unbind_one" do
-
+  describe '#unbind_one' do
     let(:binding) do
       described_class.new(person, target, association)
     end
 
-    context "when the documents are unbindable" do
-
+    context 'when the documents are unbindable' do
       before do
         binding.bind_one(target.first)
-        expect(person).to receive(:delete).never
-        expect(preference).to receive(:delete).never
+        expect(person).not_to receive(:delete)
+        expect(preference).not_to receive(:delete)
         binding.unbind_one(target.first)
       end
 
-      it "removes the inverse relation" do
+      it 'removes the inverse relation' do
         expect(preference.people).to be_empty
       end
 
-      it "removed the foreign keys" do
+      it 'removed the foreign keys' do
         expect(preference.person_ids).to be_empty
       end
 
-      it "syncs the base" do
-        expect(person._synced?("preference_ids")).to be(true)
+      it 'syncs the base' do
+        expect(person._synced?('preference_ids')).to be(true)
       end
 
-      it "syncs the inverse" do
-        expect(preference._synced?("person_ids")).to be(true)
+      it 'syncs the inverse' do
+        expect(preference._synced?('person_ids')).to be(true)
       end
     end
 
-    context "when preventing multiple db hits" do
-
+    context 'when preventing multiple db hits' do
       before do
         binding.bind_one(target.first)
       end
 
-      it "never performs a persistence operation" do
-        expect(person).to receive(:delete).never
-        expect(person).to receive(:save).never
-        expect(preference).to receive(:delete).never
-        expect(preference).to receive(:save).never
+      it 'never performs a persistence operation' do
+        expect(person).not_to receive(:delete)
+        expect(person).not_to receive(:save)
+        expect(preference).not_to receive(:delete)
+        expect(preference).not_to receive(:save)
         binding.unbind_one(target.first)
       end
     end
 
-    context "when the documents are not unbindable" do
-
-      it "does nothing" do
-        expect(person).to receive(:preferences=).never
+    context 'when the documents are not unbindable' do
+      it 'does nothing' do
+        expect(person).not_to receive(:preferences=)
         binding.unbind_one(target.first)
       end
     end
   end
 
-  context "when binding frozen documents" do
-
+  context 'when binding frozen documents' do
     let(:person) do
       Person.new
     end
 
-    context "when the child is frozen" do
-
+    context 'when the child is frozen' do
       let(:preference) do
         Preference.new.freeze
       end
@@ -149,20 +137,18 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Binding do
         person.preferences << preference
       end
 
-      it "does not set the foreign key" do
+      it 'does not set the foreign key' do
         expect(preference.person_ids).to be_nil
       end
     end
   end
 
-  context "when unbinding frozen documents" do
-
+  context 'when unbinding frozen documents' do
     let(:person) do
       Person.new
     end
 
-    context "when the child is frozen" do
-
+    context 'when the child is frozen' do
       let(:preference) do
         Preference.new
       end
@@ -173,7 +159,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Binding do
         person.preferences.delete(preference)
       end
 
-      it "does not unset the foreign key" do
+      it 'does not unset the foreign key' do
         expect(preference.person_ids).to eq([ person.id ])
       end
     end

data/spec/mongoid/association/referenced/has_and_belongs_to_many/buildable_spec.rb

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
-
   let(:base) do
     double
   end
 
   let(:options) do
-    { }
+    {}
   end
 
-  describe "#build" do
-
+  describe '#build' do
     let(:documents) do
       association.build(base, object)
     end
@@ -23,8 +20,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
       Mongoid::Association::Referenced::HasAndBelongsToMany.new(Person, :preferences, options)
     end
 
-    context "when provided ids" do
-
+    context 'when provided ids' do
       let(:object_id) do
         BSON::ObjectId.new
       end
@@ -34,16 +30,15 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
       end
 
       let(:criteria) do
-        Preference.all_of("_id" => { "$in" => object })
+        Preference.all_of('_id' => { '$in' => object })
       end
 
-      it "returns the criteria" do
+      it 'returns the criteria' do
         expect(documents).to eq(criteria)
       end
     end
 
-    context "when order specified" do
-
+    context 'when order specified' do
       let(:object_id) do
         BSON::ObjectId.new
       end
@@ -59,16 +54,15 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
       end
 
       let(:criteria) do
-        Preference.all_of("_id" => { "$in" => object }).order_by(options[:order])
+        Preference.all_of('_id' => { '$in' => object }).order_by(options[:order])
       end
 
-      it "returns the criteria" do
+      it 'returns the criteria' do
         expect(documents).to eq(criteria)
       end
     end
 
-    context "when scope is specified" do
-
+    context 'when scope is specified' do
       let(:object_id) do
         BSON::ObjectId.new
       end
@@ -84,29 +78,47 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
       end
 
       let(:criteria) do
-        Preference.all_of("_id" => { "$in" => object }).where(rating: 3)
+        Preference.all_of('_id' => { '$in' => object }).where(rating: 3)
       end
 
-      it "returns the criteria" do
+      it 'returns the criteria' do
         expect(documents).to eq(criteria)
       end
     end
 
-    context "when provided a object" do
+    context 'when provided an array of hashes' do
+      let(:object) do
+        [
+          { '_id' => BSON::ObjectId.new, 'name' => 'Emails' },
+          { '_id' => BSON::ObjectId.new, 'name' => 'SMS' }
+        ]
+      end
 
-      context "when the object is not nil" do
+      let(:preference1) do
+        Preference.new(object[0])
+      end
 
+      let(:preference2) do
+        Preference.new(object[1])
+      end
+
+      it 'returns the documents' do
+        expect(documents).to eq([ preference1, preference2 ])
+      end
+    end
+
+    context 'when provided a object' do
+      context 'when the object is not nil' do
         let(:object) do
           [ Post.new ]
         end
 
-        it "returns the objects" do
+        it 'returns the objects' do
           expect(documents).to eq(object)
         end
       end
 
-      context "when the object is nil" do
-
+      context 'when the object is nil' do
         let(:object) do
           nil
         end
@@ -115,23 +127,20 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
           Preference.none
         end
 
-        it "a criteria object" do
+        it 'a criteria object' do
           expect(documents).to eq(criteria)
         end
       end
     end
 
-    context "when no documents found in the database" do
-
-      context "when the ids are empty" do
-
-        it "returns an empty array" do
+    context 'when no documents found in the database' do
+      context 'when the ids are empty' do
+        it 'returns an empty array' do
           expect(Person.new.preferences).to be_empty
         end
       end
 
-      context "when the ids are incorrect" do
-
+      context 'when the ids are incorrect' do
         let(:person) do
           Person.create!
         end
@@ -140,7 +149,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
           person.preference_ids = [ BSON::ObjectId.new ]
         end
 
-        it "returns an empty array" do
+        it 'returns an empty array' do
           expect(person.preferences).to be_empty
         end
       end

data/spec/mongoid/association/referenced/has_and_belongs_to_many/eager_spec.rb

@@ -1,19 +1,16 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 require_relative '../has_and_belongs_to_many_models'
 
 describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
-
-  describe ".keys_from_docs" do
-
+  describe '.keys_from_docs' do
     let(:docs) do
       Person.all.to_a
     end
 
     let!(:person) do
-      Person.create!(houses: [house])
+      Person.create!(houses: [ house ])
     end
 
     let!(:house) do
@@ -25,18 +22,17 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
     end
 
     let(:eager) do
-      described_class.new([association], docs).tap do |b|
+      described_class.new([ association ], docs).tap do |b|
         b.send(:shift_association)
       end
     end
 
-    it "aggregates by the foreign key" do
-      expect(eager.send(:keys_from_docs)).to eq([house.id])
+    it 'aggregates by the foreign key' do
+      expect(eager.send(:keys_from_docs)).to eq([ house.id ])
     end
   end
 
-  describe ".includes" do
-
+  describe '.includes' do
     let(:person) do
       Person.create!
     end
@@ -45,29 +41,29 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
       Person.create!(houses: 3.times.map { House.create! })
     end
 
-    context "when including the has_and_belongs_to_many association" do
+    context 'when including the has_and_belongs_to_many association' do
       # Query count assertions require that all queries are sent using the
       # same connection object.
       require_no_multi_shard
 
-      it "queries twice" do
+      it 'queries twice' do
         expect_query(2) do
           Person.asc(:_id).includes(:houses).each do |person|
-            expect(person.houses).to_not be_nil
+            expect(person.houses).not_to be_nil
 
             expect(person.houses.length).to be(3)
           end
         end
       end
 
-      it "has all items" do
+      it 'has all items' do
         Person.asc(:_id).includes(:houses).each do |person|
           expect(person.ivar(:houses).length).to be(3)
         end
       end
     end
 
-    context "when the association is not polymorphic" do
+    context 'when the association is not polymorphic' do
       # Query count assertions require that all queries are sent using the
       # same connection object.
       require_no_multi_shard
@@ -76,59 +72,57 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
         Person.asc(:_id).includes(:preferences).last
       end
 
-      context "when the eager load has returned documents" do
-
+      context 'when the eager load has returned documents' do
         let!(:preference) do
-          person.preferences.create!(name: "testing")
+          person.preferences.create!(name: 'testing')
         end
 
         before { eager }
 
-        it "puts the documents in the parent document" do
+        it 'puts the documents in the parent document' do
           expect(eager.ivar(:preferences)).to eq([ preference ])
         end
 
-        it "does not query when touching the association" do
+        it 'does not query when touching the association' do
           expect_query(0) do
             expect(eager.preferences).to eq([ preference ])
           end
         end
 
-        it "does not query when updating the association" do
+        it 'does not query when updating the association' do
           expect_query(0) do
-            eager.preferences.first.name = "new pref"
-            expect(eager.preferences.first.name).to eq("new pref")
+            eager.preferences.first.name = 'new pref'
+            expect(eager.preferences.first.name).to eq('new pref')
           end
         end
       end
 
-      context "when the eager load has not returned documents" do
-
+      context 'when the eager load has not returned documents' do
         before { eager }
 
-        it "has an empty proxy" do
+        it 'has an empty proxy' do
           expect(eager.preferences).to eq []
         end
 
-        it "does not query when touching the association" do
+        it 'does not query when touching the association' do
           expect_query(0) do
             eager.preferences.entries
           end
         end
 
-        it "returns the proxy" do
+        it 'returns the proxy' do
           expect do
-            eager.preferences.create!(name: "testing")
-          end.to_not raise_error
+            eager.preferences.create!(name: 'testing')
+          end.not_to raise_error
         end
       end
     end
 
-    context "when the association has scope" do
+    context 'when the association has scope' do
       let!(:trainer1) { HabtmmTrainer.create!(name: 'Dave') }
       let!(:trainer2) { HabtmmTrainer.create!(name: 'Ash') }
-      let!(:animal1) { HabtmmAnimal.create!(taxonomy: 'reptile', trainers: [trainer1, trainer2]) }
-      let!(:animal2) { HabtmmAnimal.create!(taxonomy: 'bird', trainers: [trainer1, trainer2]) }
+      let!(:animal1) { HabtmmAnimal.create!(taxonomy: 'reptile', trainers: [ trainer1, trainer2 ]) }
+      let!(:animal2) { HabtmmAnimal.create!(taxonomy: 'bird', trainers: [ trainer1, trainer2 ]) }
 
       context 'when scope set by Symbol' do
         let(:eager) do
@@ -137,7 +131,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
 
         it 'eager loads the included docs' do
           expect(eager.trainers._loaded).to eq(trainer1._id => trainer1)
-          expect(eager.trainers).to eq [trainer1]
+          expect(eager.trainers).to eq [ trainer1 ]
         end
       end
 
@@ -148,12 +142,12 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
 
         it 'eager loads the included docs' do
           expect(eager.animals._loaded).to eq(animal1._id => animal1)
-          expect(eager.animals).to eq [animal1]
+          expect(eager.animals).to eq [ animal1 ]
         end
       end
     end
 
-    context "when some related documents no longer exist" do
+    context 'when some related documents no longer exist' do
       # Query count assertions require that all queries are sent using the
       # same connection object.
       require_no_multi_shard
@@ -163,26 +157,26 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
         House.collection.find(_id: Person.first.house_ids.first).delete_one
       end
 
-      it "does not accidentally trigger an extra query" do
+      it 'does not accidentally trigger an extra query' do
         expect_query(2) do
           Person.asc(:_id).includes(:houses).each do |person|
-            expect(person.houses).to_not be_nil
+            expect(person.houses).not_to be_nil
             expect(person.houses.length).to be(2)
           end
         end
       end
     end
 
-    context "when all the values for the has_and_belongs_to_many association are empty" do
+    context 'when all the values for the has_and_belongs_to_many association are empty' do
       # Query count assertions require that all queries are sent using the
       # same connection object.
       require_no_multi_shard
 
       before do
-        2.times { |i| HabtmmPerson.create! }
+        2.times { |_i| HabtmmPerson.create! }
       end
 
-      it "only queries once for the parent documents" do
+      it 'only queries once for the parent documents' do
         found_person = false
         expect_query(1) do
           HabtmmPerson.all.includes(:tickets).each do |person|

data/spec/mongoid/association/referenced/has_and_belongs_to_many/proxy_persistence_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 require_relative '../has_and_belongs_to_many_models'
 
 describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
@@ -14,7 +13,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
     end
 
     it 'references correct field' do
-      expect(company.e_ids).to eq([456])
+      expect(company.e_ids).to eq([ 456 ])
     end
 
     describe '#nullify' do
@@ -22,10 +21,10 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
         company.employees << repl_employee
         company.save!
         expect(company.employees.length).to eq(2)
-        repl_employee.c_ids = [company.c_id]
+        repl_employee.c_ids = [ company.c_id ]
         repl_employee.save!
         repl_employee.reload
-        expect(repl_employee.c_ids).to eq([123])
+        expect(repl_employee.c_ids).to eq([ 123 ])
       end
 
       context 'without replacement' do
@@ -47,9 +46,9 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
         end
 
         it 'keeps replacement associated with the parent' do
-          company.employees.nullify([repl_employee])
+          company.employees.nullify([ repl_employee ])
           repl_employee.reload
-          expect(repl_employee.c_ids).to eq([123])
+          expect(repl_employee.c_ids).to eq([ 123 ])
         end
       end
     end
@@ -61,7 +60,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
 
     it 'adds association on both ends' do
       dog.breeds << breed
-      expect(breed.dogs).to eq([dog])
+      expect(breed.dogs).to eq([ dog ])
     end
 
     context 'with primary_key and foreign_key given' do
@@ -70,7 +69,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
 
       it 'adds association on both ends' do
         company.employees << employee
-        expect(employee.companies).to eq([company])
+        expect(employee.companies).to eq([ company ])
       end
     end
   end