mongoid 6.4.4 → 7.1.7

data/spec/mongoid/{relations/bindings/referenced/many_to_many_spec.rb → association/referenced/has_and_belongs_to_many/binding_spec.rb}

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Bindings::Referenced::ManyToMany do
+describe Mongoid::Association::Referenced::HasAndBelongsToMany::Binding do
 
   let(:person) do
     Person.new
@@ -11,17 +14,17 @@ describe Mongoid::Relations::Bindings::Referenced::ManyToMany do
   end
 
   let(:target) do
-    Mongoid::Relations::Targets::Enumerable.new([ preference ])
+    Mongoid::Association::Referenced::HasMany::Targets::Enumerable.new([ preference ])
   end
 
-  let(:metadata) do
+  let(:association) do
     Person.relations["preferences"]
   end
 
   describe "#bind_one" do
 
     let(:binding) do
-      described_class.new(person, target, metadata)
+      described_class.new(person, target, association)
     end
 
     context "when the document is bindable" do
@@ -77,7 +80,7 @@ describe Mongoid::Relations::Bindings::Referenced::ManyToMany do
   describe "#unbind_one" do
 
     let(:binding) do
-      described_class.new(person, target, metadata)
+      described_class.new(person, target, association)
     end
 
     context "when the documents are unbindable" do

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::HasAndBelongsToMany::Buildable do
+
+  let(:base) do
+    double
+  end
+
+  let(:options) do
+    { }
+  end
+
+  describe "#build" do
+
+    let(:documents) do
+      association.build(base, object)
+    end
+
+    let(:association) do
+      Mongoid::Association::Referenced::HasAndBelongsToMany.new(Person, :preferences, options)
+    end
+
+    context "when provided ids" do
+
+      let(:object_id) do
+        BSON::ObjectId.new
+      end
+
+      let(:object) do
+        [ object_id ]
+      end
+
+      let(:criteria) do
+        Preference.all_of("_id" => { "$in" => object })
+      end
+
+      it "returns the criteria" do
+        expect(documents).to eq(criteria)
+      end
+    end
+
+    context "when order specified" do
+
+      let(:object_id) do
+        BSON::ObjectId.new
+      end
+
+      let(:options) do
+        {
+          order: :rating.desc
+        }
+      end
+
+      let(:object) do
+        [ object_id ]
+      end
+
+      let(:criteria) do
+        Preference.all_of("_id" => { "$in" => object }).order_by(options[:order])
+      end
+
+      it "returns the criteria" do
+        expect(documents).to eq(criteria)
+      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
+          expect(documents).to eq(object)
+        end
+      end
+
+      context "when the object is nil" do
+
+        let(:object) do
+          nil
+        end
+
+        let(:criteria) do
+          Preference.all_of("_id" => { "$in" => [] })
+        end
+
+        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
+          expect(Person.new.preferences).to be_empty
+        end
+      end
+
+      context "when the ids are incorrect" do
+
+        let(:person) do
+          Person.create
+        end
+
+        before do
+          person.preference_ids = [ BSON::ObjectId.new ]
+        end
+
+        it "returns an empty array" do
+          expect(person.preferences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/{relations/eager/has_and_belongs_to_many_spec.rb → association/referenced/has_and_belongs_to_many/eager_spec.rb}

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
+require_relative '../has_and_belongs_to_many_models'
 
-describe Mongoid::Relations::Eager::HasAndBelongsToMany do
+describe Mongoid::Association::Referenced::HasAndBelongsToMany::Eager do
 
   describe ".keys_from_docs" do
 
@@ -16,18 +20,18 @@ describe Mongoid::Relations::Eager::HasAndBelongsToMany do
       House.create!
     end
 
-    let(:metadata) do
+    let(:association) do
       Person.reflect_on_association(:houses)
     end
 
     let(:eager) do
-      described_class.new([metadata], docs).tap do |b|
-        b.shift_metadata
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
       end
     end
 
     it "aggregates by the foreign key" do
-      expect(eager.keys_from_docs).to eq([house.id])
+      expect(eager.send(:keys_from_docs)).to eq([house.id])
     end
   end
 
@@ -41,7 +45,10 @@ describe Mongoid::Relations::Eager::HasAndBelongsToMany do
       Person.create!(houses: 3.times.map { House.create! })
     end
 
-    context "when including the has_and_belongs_to_many relation" 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
         expect_query(2) do
@@ -60,7 +67,10 @@ describe Mongoid::Relations::Eager::HasAndBelongsToMany do
       end
     end
 
-    context "when the relation 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
 
       let(:eager) do
         Person.asc(:_id).includes(:preferences).last
@@ -115,6 +125,10 @@ describe Mongoid::Relations::Eager::HasAndBelongsToMany do
     end
 
     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
+
       before do
         # Deleting the first one to meet Builders::Referenced::ManyToMany#query?
         House.collection.find(_id: Person.first.house_ids.first).delete_one
@@ -129,5 +143,26 @@ describe Mongoid::Relations::Eager::HasAndBelongsToMany do
         end
       end
     end
+
+    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! }
+      end
+
+      it "only queries once for the parent documents" do
+        found_person = false
+        expect_query(1) do
+          HabtmmPerson.all.includes(:tickets).each do |person|
+            expect(person.tickets).to eq []
+            found_person = true
+          end
+        end
+        expect(found_person).to be true
+      end
+    end
   end
 end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+require_relative '../has_and_belongs_to_many_models'
+
+describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
+  context 'with primary_key and foreign_key given' do
+    let(:company) { HabtmmCompany.create!(c_id: 123) }
+    let(:employee) { HabtmmEmployee.create!(e_id: 456) }
+
+    before do
+      company.employees << employee
+    end
+
+    it 'references correct field' do
+      expect(company.e_ids).to eq([456])
+    end
+
+    describe '#nullify' do
+      before do
+        company.employees << repl_employee
+        company.save!
+        expect(company.employees.length).to eq(2)
+        repl_employee.c_ids = [company.c_id]
+        repl_employee.save!
+        repl_employee.reload
+        expect(repl_employee.c_ids).to eq([123])
+      end
+
+      context 'without replacement' do
+        let(:repl_employee) { HabtmmEmployee.create!(e_id: 444) }
+
+        it 'disassociates child from parent' do
+          company.employees.nullify
+          repl_employee.reload
+          expect(repl_employee.c_ids).to eq([])
+        end
+      end
+
+      context 'with replacement' do
+        let(:repl_employee) { HabtmmEmployee.create!(e_id: 444) }
+
+        before do
+          company.employees << repl_employee
+          expect(company.employees.length).to eq(2)
+        end
+
+        it 'keeps replacement associated with the parent' do
+          company.employees.nullify([repl_employee])
+          repl_employee.reload
+          expect(repl_employee.c_ids).to eq([123])
+        end
+      end
+    end
+  end
+
+  describe '#<<' do
+    let(:dog) { Dog.create! }
+    let(:breed) { Breed.create! }
+
+    it 'adds association on both ends' do
+      dog.breeds << breed
+      expect(breed.dogs).to eq([dog])
+    end
+
+    context 'with primary_key and foreign_key given' do
+      let(:company) { HabtmmCompany.create!(c_id: 123) }
+      let(:employee) { HabtmmEmployee.create!(e_id: 456) }
+
+      it 'adds association on both ends' do
+        company.employees << employee
+        expect(employee.companies).to eq([company])
+      end
+    end
+  end
+end

data/spec/mongoid/{relations/referenced/many_to_many_spec.rb → association/referenced/has_and_belongs_to_many/proxy_spec.rb}

@@ -1,11 +1,18 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Referenced::ManyToMany do
+describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
 
-  before(:all) do
+  around(:each) do |example|
+    original_raise_not_found_error = Mongoid.raise_not_found_error
+    original_preferences_association = Person.relations["preferences"]
     Mongoid.raise_not_found_error = true
-    Person.autosave(Person.relations["preferences"].merge!(autosave: true))
-    Person._synced(Person.relations["preferences"])
+    Person.has_and_belongs_to_many :preferences, autosave: true
+    example.run
+    Mongoid.raise_not_found_error = original_raise_not_found_error
+    Person.relations["preferences"] = original_preferences_association
   end
 
   after(:all) do
@@ -814,6 +821,82 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
   end
 
+  describe "when self-referencing" do
+    let!(:parent) do
+      Vertex.create
+    end
+
+    let!(:child) do
+      Vertex.create(parents: [parent])
+    end
+
+    before do
+      parent.reload
+      child.reload
+    end
+
+    it "sets the parent" do
+      expect(child.parents).to include(parent)
+    end
+
+    it "sets the parent id" do
+      expect(child.parent_ids).to include(parent.id)
+    end
+
+    it "sets the child" do
+      expect(parent.children).to include(child)
+    end
+
+    it "sets the child id" do
+      expect(parent.child_ids).to include(child.id)
+    end
+
+    describe "#update" do
+      before do
+        child.update(parents: [parent])
+      end
+
+      it "sets the parent" do
+        expect(child.parents).to include(parent)
+      end
+
+      it "sets the parent id" do
+        expect(child.parent_ids).to include(parent.id)
+      end
+
+      it "sets the child" do
+        expect(parent.children).to include(child)
+      end
+
+      it "sets the child id" do
+        expect(parent.child_ids).to include(child.id)
+      end
+
+      describe "when reloading" do
+        before do
+          parent.reload
+          child.reload
+        end
+
+        it "sets the parent" do
+          expect(child.parents).to include(parent)
+        end
+
+        it "sets the parent id" do
+          expect(child.parent_ids).to include(parent.id)
+        end
+
+        it "sets the child" do
+          expect(parent.children).to include(child)
+        end
+
+        it "sets the child id" do
+          expect(parent.child_ids).to include(child.id)
+        end
+      end
+    end
+  end
+
   [ nil, [] ].each do |value|
 
     describe "#= #{value}" do
@@ -1041,27 +1124,6 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
   end
 
-  describe ".builder" do
-
-    let(:builder_klass) do
-      Mongoid::Relations::Builders::Referenced::ManyToMany
-    end
-
-    let(:document) do
-      double
-    end
-
-    let(:metadata) do
-      double(extension?: false)
-    end
-
-    it "returns the embedded in builder" do
-      expect(
-        described_class.builder(nil, metadata, document)
-      ).to be_a_kind_of(builder_klass)
-    end
-  end
-
   describe "#clear" do
 
     context "when the relation is not polymorphic" do
@@ -1695,6 +1757,43 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
     end
 
+    describe "#any?" do
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when nothing exists on the relation" do
+
+        context "when no document is added" do
+
+          let!(:sandwich) do
+            Sandwich.create!
+          end
+
+          it "returns false" do
+            expect(sandwich.meats.any?).to be false
+          end
+        end
+
+        context "when the document is destroyed" do
+
+          before do
+            Meat.create!
+          end
+
+          let!(:sandwich) do
+            Sandwich.create!
+          end
+
+          it "returns false" do
+            sandwich.destroy
+            expect(sandwich.meats.any?).to be false
+          end
+        end
+      end
+    end
+
     context "when documents have been persisted" do
 
       let!(:preference) do
@@ -1784,6 +1883,107 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
   end
 
+  describe "#any?" do
+
+    let(:sandwich) do
+      Sandwich.create
+    end
+
+    context "when nothing exists on the relation" do
+
+      context "when no document is added" do
+
+        let!(:sandwich) do
+          Sandwich.create!
+        end
+
+        it "returns false" do
+          expect(sandwich.meats.any?).to be false
+        end
+      end
+
+      context "when the document is destroyed" do
+
+        before do
+          Meat.create!
+        end
+
+        let!(:sandwich) do
+          Sandwich.create!
+        end
+
+        it "returns false" do
+          sandwich.destroy
+          expect(sandwich.meats.any?).to be false
+        end
+      end
+    end
+
+    context "when appending to a relation and _loaded/_unloaded are empty" do
+
+      let!(:sandwich) do
+        Sandwich.create!
+      end
+
+      before do
+        sandwich.meats << Meat.new
+      end
+
+      it "returns true" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+
+    context "when appending to a relation in a transaction" do
+      require_transaction_support
+
+      let!(:sandwich) do
+        Sandwich.create!
+      end
+
+      it "returns true" do
+        sandwich.with_session do |session|
+          session.with_transaction do
+            expect{ sandwich.meats << Meat.new }.to_not raise_error
+            expect(sandwich.meats.any?).to be true
+          end
+        end
+      end
+    end
+
+    context "when documents have been persisted" do
+
+      let!(:meat) do
+        sandwich.meats.create
+      end
+
+      it "returns true" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+
+    context "when documents have not been persisted" do
+
+      let!(:meat) do
+        sandwich.meats.build
+      end
+
+      it "returns false" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+
+    context "when new documents exist in the database" do
+      before do
+        Meat.create(sandwiches: [sandwich])
+      end
+
+      it "returns true" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+  end
+
   [ :create, :create! ].each do |method|
 
     describe "##{method}" do
@@ -2175,8 +2375,8 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           let!(:deleted) do
             person.preferences.send(
-              method,
-              { name: "Testing" }
+                method,
+                { name: "Testing" }
             )
           end
 
@@ -2365,7 +2565,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           let(:preferences) do
             person.preferences.find(
-              [ unrelated_pref.id, unrelated_pref_two.id ]
+                [ unrelated_pref.id, unrelated_pref_two.id ]
             )
           end
 
@@ -2543,20 +2743,6 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
   end
 
-  describe ".foreign_key_suffix" do
-
-    it "returns _ids" do
-      expect(described_class.foreign_key_suffix).to eq("_ids")
-    end
-  end
-
-  describe ".macro" do
-
-    it "returns has_and_belongs_to_many" do
-      expect(described_class.macro).to eq(:has_and_belongs_to_many)
-    end
-  end
-
   describe "#max" do
 
     let(:person) do
@@ -2641,7 +2827,8 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         expect(preferences).to eq([ preference_one ])
       end
 
-      context 'when providing a collation', if: collation_supported? do
+      context 'when providing a collation' do
+        min_server_version '3.4'
 
         let(:preferences) do
           person.preferences.where(name: "FIRST").collation(locale: 'en_US', strength: 2).to_a
@@ -2833,9 +3020,13 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       person.preferences
     end
 
-    Array.public_instance_methods.each do |method|
+    Array.public_instance_methods.sort.each do |method|
+
+      context "when checking Array##{method}" do
 
-      context "when checking #{method}" do
+        before do
+          expect([].respond_to?(method)).to be true
+        end
 
         it "returns true" do
           expect(preferences.respond_to?(method)).to be true
@@ -2843,9 +3034,9 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
     end
 
-    Mongoid::Relations::Referenced::Many.public_instance_methods.each do |method|
+    Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy.public_instance_methods.sort.each do |method|
 
-      context "when checking #{method}" do
+      context "when checking Proxy##{method}" do
 
         it "returns true" do
           expect(preferences.respond_to?(method)).to be true
@@ -2853,9 +3044,9 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
     end
 
-    Preference.scopes.keys.each do |method|
+    Preference.scopes.keys.sort.each do |method|
 
-      context "when checking #{method}" do
+      context "when checking scope #{method}" do
 
         it "returns true" do
           expect(preferences.respond_to?(method)).to be true
@@ -2864,29 +3055,38 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
   end
 
-  describe ".stores_foreign_key?" do
-
-    it "returns true" do
-      expect(described_class.stores_foreign_key?).to be true
-    end
-  end
-
   describe "#scoped" do
 
-    let(:person) do
-      Person.new
-    end
-
     let(:scoped) do
       person.preferences.scoped
     end
 
-    it "returns the relation criteria" do
-      expect(scoped).to be_a(Mongoid::Criteria)
+    context 'when association is empty' do
+
+      let(:person) do
+        Person.new
+      end
+
+      it "returns the relation criteria" do
+        expect(scoped).to be_a(Mongoid::Criteria)
+      end
+
+      it "returns with an empty selector" do
+        expect(scoped.selector).to eq("_id" => { "$in" => [] })
+      end
     end
 
-    it "returns with an empty selector" do
-      expect(scoped.selector).to eq({ "$and" => [{ "_id" => { "$in" => [] }}]})
+    context 'when association is not empty' do
+
+      let(:person) do
+        Person.create!(preferences: [
+          Preference.new(id: 123),
+        ])
+      end
+
+      it "returns with a selector including association element ids" do
+        expect(scoped.selector).to eq("_id" => { "$in" => [123] })
+      end
     end
   end
 
@@ -2976,33 +3176,6 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
   end
 
-  describe ".valid_options" do
-
-    it "returns the valid options" do
-      expect(described_class.valid_options).to eq(
-        [
-          :after_add,
-          :after_remove,
-          :autosave,
-          :before_add,
-          :before_remove,
-          :dependent,
-          :foreign_key,
-          :index,
-          :order,
-          :primary_key
-        ]
-      )
-    end
-  end
-
-  describe ".validation_default" do
-
-    it "returns true" do
-      expect(described_class.validation_default).to be true
-    end
-  end
-
   context "when setting the ids directly after the documents" do
 
     let!(:person) do
@@ -3023,7 +3196,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
     before do
       person.update_attributes(
-        houses: [ wife_house, exwife_house, girlfriend_house ]
+          houses: [ wife_house, exwife_house, girlfriend_house ]
       )
       person.update_attributes(house_ids: [ girlfriend_house.id ])
     end
@@ -3208,14 +3381,14 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
     it "orders the documents" do
       expect(person.ordered_preferences(true)).to eq(
-        [preference_two, preference_three, preference_one]
-      )
+                                                      [preference_two, preference_three, preference_one]
+                                                  )
     end
 
     it "chains default criteria with additional" do
       expect(person.ordered_preferences.order_by(:name.desc).to_a).to eq(
-        [preference_three, preference_two, preference_one]
-      )
+                                                                          [preference_three, preference_two, preference_one]
+                                                                      )
     end
   end
 
@@ -3273,7 +3446,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
       before do
         Preference.collection.find({ _id: preference_one.id }).
-          update_one({ "$set" => { name: "reloaded" }})
+            update_one({ "$set" => { name: "reloaded" }})
       end
 
       let(:reloaded) do
@@ -3367,8 +3540,8 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
       it "persists the change in id order" do
         expect(reloaded.preference_ids).to eq(
-          [ preference_two.id, preference_one.id ]
-        )
+                                               [ preference_two.id, preference_one.id ]
+                                           )
       end
     end
 
@@ -3380,7 +3553,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
       before do
         person.preference_ids =
-          [ preference_two.id, preference_one.id, preference_three.id ]
+            [ preference_two.id, preference_one.id, preference_three.id ]
         person.save
       end
 
@@ -3390,8 +3563,8 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
       it "also persists the change in id order" do
         expect(reloaded.preference_ids).to eq(
-          [ preference_two.id, preference_one.id, preference_three.id ]
-        )
+                                               [ preference_two.id, preference_one.id, preference_three.id ]
+                                           )
       end
     end
 
@@ -3403,10 +3576,10 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
       before do
         person.preference_ids =
-          [ preference_one.id, preference_two.id, preference_three.id ]
+            [ preference_one.id, preference_two.id, preference_three.id ]
         person.save
         person.preference_ids =
-          [ preference_three.id, preference_two.id ]
+            [ preference_three.id, preference_two.id ]
         person.save
       end
 
@@ -3416,8 +3589,8 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
       it "also persists the change in id order" do
         expect(reloaded.preference_ids).to eq(
-          [ preference_three.id, preference_two.id ]
-        )
+                                               [ preference_three.id, preference_two.id ]
+                                           )
       end
     end
   end
@@ -3543,9 +3716,8 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         field :n, type: String, as: :name
 
         has_and_belongs_to_many :distributors,
-          foreign_key: :d_ids,
-          inverse_of: 'p',
-          inverse_class_name: 'Distributor'
+                                foreign_key: :d_ids,
+                                inverse_of: 'p'
       end
 
       class Distributor
@@ -3554,9 +3726,8 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         field :n, type: String, as: :name
 
         has_and_belongs_to_many :projects,
-          foreign_key: :p_ids,
-          inverse_of: 'd',
-          inverse_class_name: 'Project'
+                                foreign_key: :p_ids,
+                                inverse_of: 'd'
       end
     end