mongoid 7.0.13 → 8.0.8

data/spec/mongoid/association/referenced/has_and_belongs_to_many_models.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 class HabtmmCompany
   include Mongoid::Document
 
   field :c_id, type: Integer
   field :e_ids, type: Array
-  has_and_belongs_to_many :employees, primary_key: :e_id, foreign_key: :e_ids, class_name: 'HabtmmEmployee'
+  has_and_belongs_to_many :employees, class_name: 'HabtmmEmployee',
+    primary_key: :e_id, foreign_key: :e_ids,
+    inverse_primary_key: :c_id, inverse_foreign_key: :c_ids
 end
 
 class HabtmmEmployee
@@ -12,7 +16,28 @@ class HabtmmEmployee
   field :e_id, type: Integer
   field :c_ids, type: Array
   field :habtmm_company_ids, type: Array
-  has_and_belongs_to_many :companies, primary_key: :c_id, foreign_key: :c_ids, class_name: 'HabtmmCompany'
+  has_and_belongs_to_many :companies, class_name: 'HabtmmCompany',
+    primary_key: :c_id, foreign_key: :c_ids,
+    inverse_primary_key: :e_id, inverse_foreign_key: :e_ids
+end
+
+class HabtmmContract
+  include Mongoid::Document
+
+  has_and_belongs_to_many :signatures, class_name: 'HabtmmSignature'
+
+  field :item, type: String
+end
+
+class HabtmmSignature
+  include Mongoid::Document
+
+  field :favorite_signature, default: ->{ contracts.first.signature_ids.first if contracts.first }
+
+  has_and_belongs_to_many :contracts, class_name: 'HabtmmContract'
+
+  field :name, type: String
+  field :year, type: Integer
 end
 
 class HabtmmTicket
@@ -24,3 +49,44 @@ class HabtmmPerson
 
   has_and_belongs_to_many :tickets, class_name: 'HabtmmTicket'
 end
+
+class HabtmmTrainer
+  include Mongoid::Document
+
+  field :name, type: String
+
+  has_and_belongs_to_many :animals, inverse_of: :trainers, class_name: 'HabtmmAnimal', scope: :reptile
+end
+
+class HabtmmAnimal
+  include Mongoid::Document
+
+  field :taxonomy, type: String
+
+  scope :reptile, -> { where(taxonomy: 'reptile') }
+
+  has_and_belongs_to_many :trainers, inverse_of: :animals, class_name: 'HabtmmTrainer', scope: -> { where(name: 'Dave') }
+end
+
+class HabtmmSchool
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  has_and_belongs_to_many :students, class_name: 'HabtmmStudent'
+
+  field :after_destroy_triggered, default: false
+
+  accepts_nested_attributes_for :students, allow_destroy: true
+end
+
+class HabtmmStudent
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  has_and_belongs_to_many :schools, class_name: 'HabtmmSchool'
+
+  after_destroy do |doc|
+    schools.first.update_attributes!(after_destroy_triggered: true) unless schools.empty?
+  end
+end
+

data/spec/mongoid/association/referenced/has_and_belongs_to_many_query_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative './has_and_belongs_to_many_models'
+
+describe Mongoid::Association::Referenced::HasAndBelongsToMany do
+  context 'when projecting with #only' do
+    before do
+      contract = HabtmmContract.create!(item: 'foo')
+      contract.signatures << HabtmmSignature.create!(contracts: [contract], name: 'Dave', year: 2019)
+      contract.save!
+    end
+
+    let(:contract) do
+      HabtmmContract.where(item: 'foo').only(:signature_ids,
+        'signatures._id', 'signatures.name').first
+    end
+
+    let(:signature) { contract.signatures.first }
+
+    it 'populates specified fields only' do
+      pending 'https://jira.mongodb.org/browse/MONGOID-4704'
+
+      expect(signature.name).to eq('Dave')
+      # has a default value specified in the model
+      expect do
+        signature.year
+      end.to raise_error(ActiveModel::MissingAttributeError)
+      expect(signature.attributes.keys).to eq(['_id', 'name'])
+    end
+
+    # Delete this test when https://jira.mongodb.org/browse/MONGOID-4704 is
+    # implemented and above test is unpended
+    it 'fetches all fields' do
+      expect(signature.name).to eq('Dave')
+      expect(signature.year).to eq(2019)
+    end
+  end
+end

data/spec/mongoid/association/referenced/has_and_belongs_to_many_spec.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "spec_helper"
+require_relative "./has_and_belongs_to_many_models"
 
 describe Mongoid::Association::Referenced::HasAndBelongsToMany do
 
@@ -491,6 +494,27 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany do
     end
   end
 
+  describe '#scope' do
+
+    context 'when scope is specified in the options' do
+
+      let(:options) do
+        { scope: -> { unscoped.where(foo: :bar) } }
+      end
+
+      it 'returns a Criteria Queryable Key' do
+        expect(association.scope).to be_a(Proc)
+      end
+    end
+
+    context 'when scope is not specified in the options' do
+
+      it 'returns nil' do
+        expect(association.scope).to be_nil
+      end
+    end
+  end
+
   describe '#as' do
 
     it 'returns nil' do
@@ -985,8 +1009,8 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany do
 
   describe '#foreign_key_check' do
 
-    it 'returns the foreign_key followed by "_changed?"' do
-      expect(association.foreign_key_check).to eq('has_many_right_object_ids_changed?')
+    it 'returns the foreign_key followed by "_previously_changed?"' do
+      expect(association.foreign_key_check).to eq('has_many_right_object_ids_previously_changed?')
     end
   end
 
@@ -1013,15 +1037,68 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany do
 
   describe '#inverse_foreign_key' do
 
-    it 'returns nil' do
+    it 'returns generated key' do
       expect(association.inverse_foreign_key).to eq('has_many_left_object_ids')
     end
+
+    context 'with inverse given' do
+      let(:options) do
+        { inverse_of: 'foo' }
+      end
+
+      it 'returns configured key' do
+        expect(association.inverse_foreign_key).to eq('foo_ids')
+      end
+    end
+
+    context 'with primary_key and foreign_key given' do
+      let(:options) do
+        { primary_key: 'foo', foreign_key: 'foo_ref',
+          inverse_primary_key: 'bar', inverse_foreign_key: 'bar_ref' }
+      end
+
+      it 'returns configured key' do
+        expect(association.inverse_foreign_key).to eq('bar_ref')
+      end
+    end
+
+    context "when using a model that uses the class_name option" do
+      let(:inverse_foreign_key) { HabtmmSchool.relations[:students].inverse_foreign_key }
+      it "gets the correct inverse foreign key" do
+        expect(inverse_foreign_key).to eq("school_ids")
+      end
+    end
   end
 
   describe '#inverse_foreign_key_setter' do
 
-    it 'returns nil' do
+    it 'returns generated method name' do
       expect(association.inverse_foreign_key_setter).to eq('has_many_left_object_ids=')
     end
   end
+
+  context "when adding an object to the association" do
+    let!(:start_time) { Timecop.freeze(Time.at(Time.now.to_i)) }
+
+    let(:update_time) do
+      Timecop.freeze(Time.at(Time.now.to_i) + 2)
+    end
+
+    after do
+      Timecop.return
+    end
+
+    let!(:school) { HabtmmSchool.create! }
+    let!(:student) { HabtmmStudent.create! }
+
+    before do
+      update_time
+      school.update(students: [student])
+    end
+
+    it "updates the updated at" do
+      pending "MONGOID-4953"
+      expect(school.updated_at).to eq(update_time)
+    end
+  end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Association::Referenced::HasMany::Binding do
@@ -11,7 +13,7 @@ describe Mongoid::Association::Referenced::HasMany::Binding do
   end
 
   let(:target) do
-    Mongoid::Association::Referenced::HasMany::Targets::Enumerable.new([ post ])
+    Mongoid::Association::Referenced::HasMany::Enumerable.new([ post ])
   end
 
   let(:association) do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Association::Referenced::HasMany::Buildable do
@@ -56,6 +58,27 @@ describe Mongoid::Association::Referenced::HasMany::Buildable do
       end
     end
 
+    context "when scope is specified" do
+
+      let(:options) do
+        {
+          scope: -> { where(rating: 3) },
+        }
+      end
+
+      let(:object) do
+        BSON::ObjectId.new
+      end
+
+      let(:criteria) do
+        Post.where(association.foreign_key => object, rating: 3)
+      end
+
+      it "adds the ordering to the criteria" do
+        expect(documents).to eq(criteria)
+      end
+    end
+
     context "when the relation is polymorphic" do
 
       let(:options) do
@@ -115,5 +138,114 @@ describe Mongoid::Association::Referenced::HasMany::Buildable do
         end
       end
     end
+
+    context 'when the object is already associated with another object' do
+
+      context "when using <<" do
+
+        let(:person1) do
+          Person.new
+        end
+
+        let(:person2) do
+          Person.new
+        end
+
+        let(:drug) do
+          Drug.new
+        end
+
+        before do
+          person1.drugs << drug
+          person2.drugs << drug
+        end
+
+        it 'clears the object of its previous association' do
+          expect(person1.drugs).to eq([])
+          expect(person1.drug_ids).to eq([])
+          expect(person2.drugs).to eq([drug])
+          expect(person2.drug_ids).to eq([drug._id])
+        end
+      end
+
+      context "when using concat" do
+
+        let(:person1) do
+          Person.new
+        end
+
+        let(:person2) do
+          Person.new
+        end
+
+        let(:drug) do
+          Drug.new
+        end
+
+        before do
+          person1.drugs.concat([drug])
+          person2.drugs.concat([drug])
+        end
+
+        it 'clears the object of its previous association' do
+          expect(person1.drugs).to eq([])
+          expect(person1.drug_ids).to eq([])
+          expect(person2.drugs).to eq([drug])
+          expect(person2.drug_ids).to eq([drug._id])
+        end
+      end
+
+      context "when using =" do
+
+        let(:person1) do
+          Person.new
+        end
+
+        let(:person2) do
+          Person.new
+        end
+
+        let(:drug) do
+          Drug.new
+        end
+
+        before do
+          person1.drugs = [drug]
+          person2.drugs = [drug]
+        end
+
+        it 'clears the object of its previous association' do
+          expect(person1.drugs).to eq([])
+          expect(person1.drug_ids).to eq([])
+          expect(person2.drugs).to eq([drug])
+          expect(person2.drug_ids).to eq([drug._id])
+        end
+      end
+
+      context "when using = on the same document twice" do
+
+        let(:person1) do
+          Person.new
+        end
+
+        let(:person2) do
+          Person.new
+        end
+
+        let(:drug) do
+          Drug.new
+        end
+
+        before do
+          person1.drugs = [drug]
+          person1.drugs = [drug]
+        end
+
+        it 'clears the object of its previous association' do
+          expect(person1.drugs).to eq([drug])
+          expect(person1.drug_ids).to eq([drug._id])
+        end
+      end
+    end
   end
 end

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

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "spec_helper"
+require_relative '../has_many_models'
 
 describe Mongoid::Association::Referenced::HasMany::Eager do
 
@@ -63,9 +66,15 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
       eager.send(:set_on_parent, person.id, :foo)
     end
 
-    it "doesnt call an extra query" do
-      expect_query(0) do
-        eager.send(:set_on_parent, person.id, :foo)
+    context 'when able to make query count assertions' do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      it "doesnt call an extra query" do
+        expect_query(0) do
+          eager.send(:set_on_parent, person.id, :foo)
+        end
       end
     end
   end
@@ -77,6 +86,9 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
     end
 
     context "when including the has_many relation" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
 
       before do
         3.times { Drug.create!(person: person) }
@@ -103,11 +115,14 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
     end
 
     context "when the relation is not polymorphic" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
 
       context "when the eager load has returned documents" do
 
         let!(:post) do
-          person.posts.create(title: "testing")
+          person.posts.create!(title: "testing")
         end
 
         let!(:eager) do
@@ -161,7 +176,7 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
 
         it "returns the proxy" do
           expect do
-            eager.posts.create(title: "testing")
+            eager.posts.create!(title: "testing")
           end.to_not raise_error
         end
       end
@@ -173,11 +188,11 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
         end
 
         let!(:person_two) do
-          Person.create(username: "durran")
+          Person.create!(username: "durran")
         end
 
         let!(:post) do
-          person_one.posts.create(title: "testing")
+          person_one.posts.create!(title: "testing")
         end
 
         let!(:eager) do
@@ -234,11 +249,11 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
     context "when the relation is polymorphic" do
 
       let!(:movie) do
-        Movie.create(name: "Bladerunner")
+        Movie.create!(name: "Bladerunner")
       end
 
       let!(:rating) do
-        movie.ratings.create(value: 10)
+        movie.ratings.create!(value: 10)
       end
 
       let!(:eager) do
@@ -255,5 +270,21 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
         end
       end
     end
+
+    context "when the association has scope" do
+      let!(:trainer1) { HmmTrainer.create!(name: 'Dave') }
+      let!(:trainer2) { HmmTrainer.create!(name: 'Ash') }
+      let!(:animal1) { HmmAnimal.create!(taxonomy: 'reptile', trainer: trainer1) }
+      let!(:animal2) { HmmAnimal.create!(taxonomy: 'bird', trainer: trainer1) }
+
+      let(:eager) do
+        HmmTrainer.includes(:animals).where(_id: trainer1._id).to_a.first
+      end
+
+      it 'eager loads the included docs' do
+        expect(eager.animals._loaded).to eq(animal1._id => animal1)
+        expect(eager.animals).to eq [animal1]
+      end
+    end
   end
 end