mongoid 7.5.4 → 8.0.1

data/spec/integration/persistence/range_field_spec.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Range field persistence' do
+  let!(:person) { Person.create!(field => value).reload }
+  subject { person.send(field) }
+  let(:now_utc) { Time.now }
+  let(:later_utc) { now_utc + 10.minutes }
+  let(:now_in_zone) { now_utc.in_time_zone('Asia/Tokyo') }
+  let(:later_in_zone) { later_utc.in_time_zone('Asia/Tokyo') }
+
+  context 'static field' do
+    let(:field) { :range }
+
+    context 'when Integer' do
+      let(:value) { 1..3 }
+      it do
+        expect(subject).to eq(1..3)
+      end
+    end
+
+    context 'when Integer exclude_end' do
+      let(:value) { 1...3 }
+      it { expect(subject).to eq(1...3) }
+    end
+
+    context 'when endless' do
+      ruby_version_gte '2.6'
+      let(:value) { eval('3..') }
+      it { expect(subject).to eq(eval('3..')) }
+    end
+
+    context 'when endless exclude_end' do
+      ruby_version_gte '2.6'
+      let(:value) { eval('3...') }
+      it { expect(subject).to eq(eval('3...')) }
+    end
+
+    context 'when beginning-less' do
+      ruby_version_gte '2.7'
+      let(:value) { eval('..3') }
+      it { expect(subject).to eq(eval('..3')) }
+    end
+
+    context 'when beginning-less exclude_end' do
+      ruby_version_gte '2.7'
+      let(:value) { eval('...3') }
+      it { expect(subject).to eq(eval('...3')) }
+    end
+
+    context 'when Hash<String, Integer>' do
+      let(:value) { { 'min' => 1, 'max' => 3 } }
+      it { expect(subject).to eq(1..3) }
+    end
+
+    context 'when Hash<String, Integer> exclude_end' do
+      let(:value) { { 'min' => 1, 'max' => 3, 'exclude_end' => true } }
+      it { expect(subject).to eq(1...3) }
+    end
+
+    context 'when Hash<Symbol, Integer>' do
+      let(:value) { { min: 1, max: 3 } }
+      it { expect(subject).to eq(1..3) }
+    end
+
+    context 'when Hash<Symbol, Integer> exclude_end' do
+      let(:value) { { min: 1, max: 3, exclude_end: true } }
+      it { expect(subject).to eq(1...3) }
+    end
+
+    context 'when Time' do
+      let(:value) { now_utc..later_utc }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq false
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+
+    context 'when Time exclude_end' do
+      let(:value) { now_utc...later_utc }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq true
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, Time>' do
+      let(:value) { { 'min' => now_utc, 'max' => later_utc } }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq false
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, Time> exclude_end' do
+      let(:value) { { 'min' => now_utc, 'max' => later_utc, 'exclude_end' => true } }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq true
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+
+    context 'when ActiveSupport::TimeWithZone' do
+      let(:value) { now_in_zone..later_in_zone }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq false
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+
+    context 'when ActiveSupport::TimeWithZone exclude_end' do
+      let(:value) { now_in_zone...later_in_zone }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq true
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, ActiveSupport::TimeWithZone>' do
+      let(:value) { { 'min' => now_in_zone, 'max' => later_in_zone } }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq false
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, ActiveSupport::TimeWithZone> exclude_end' do
+      let(:value) { { 'min' => now_in_zone, 'max' => later_in_zone, 'exclude_end' => true } }
+
+      it do
+        expect(subject).to be_a Range
+        expect(subject.exclude_end?).to eq true
+        expect(subject.first).to be_within(0.01.second).of(now_utc)
+        expect(subject.last).to be_within(0.01.second).of(later_utc)
+        expect(subject.first.class).to eq Time
+        expect(subject.last.class).to eq Time
+      end
+    end
+  end
+
+  context 'dynamic field' do
+    let(:field) { :dynamic }
+
+    context 'when Integer' do
+      let(:value) { 1..3 }
+      it do
+        expect(subject).to eq('max' => 3, 'min' => 1)
+      end
+    end
+
+    context 'when Integer exclude_end' do
+      let(:value) { 1...3 }
+      it { expect(subject).to eq('max' => 3, 'min' => 1, 'exclude_end' => true) }
+    end
+
+    context 'when descending' do
+      let(:value) { 3..1 }
+      it { expect(subject).to eq('max' => 1, 'min' => 3) }
+    end
+
+    context 'when descending exclude_end' do
+      let(:value) { 3...1 }
+      it { expect(subject).to eq('max' => 1, 'min' => 3, 'exclude_end' => true) }
+    end
+
+    context 'when endless' do
+      ruby_version_gte '2.6'
+      let(:value) { eval('3..') }
+      it { expect(subject).to eq('min' => 3) }
+    end
+
+    context 'when endless exclude_end' do
+      ruby_version_gte '2.6'
+      let(:value) { eval('3...') }
+      it { expect(subject).to eq('min' => 3, 'exclude_end' => true) }
+    end
+
+    context 'when beginning-less' do
+      ruby_version_gte '2.7'
+      let(:value) { eval('..3') }
+      it { expect(subject).to eq('max' => 3) }
+    end
+
+    context 'when beginning-less exclude_end' do
+      ruby_version_gte '2.7'
+      let(:value) { eval('...3') }
+      it { expect(subject).to eq('max' => 3, 'exclude_end' => true) }
+    end
+
+    context 'when Hash<String, Integer>' do
+      let(:value) { { 'min' => 1, 'max' => 3 } }
+      it { expect(subject).to eq('max' => 3, 'min' => 1) }
+    end
+
+    context 'when Hash<String, Integer> exclude_end' do
+      let(:value) { { 'min' => 1, 'max' => 3, 'exclude_end' => true } }
+      it { expect(subject).to eq('max' => 3, 'min' => 1, 'exclude_end' => true) }
+    end
+
+    context 'when Hash<Symbol, Integer>' do
+      let(:value) { { min: 1, max: 3 } }
+      it { expect(subject).to eq('max' => 3, 'min' => 1) }
+    end
+
+    context 'when Hash<Symbol, Integer> exclude_end' do
+      let(:value) { { min: 1, max: 3, exclude_end: true } }
+      it { expect(subject).to eq('max' => 3, 'min' => 1, 'exclude_end' => true) }
+    end
+
+    context 'when Time' do
+      let(:value) { now_utc..later_utc }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq nil
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+
+    context 'when Time exclude_end' do
+      let(:value) { now_utc...later_utc }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq true
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, Time>' do
+      let(:value) { { 'min' => now_utc, 'max' => later_utc } }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq nil
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, Time> exclude_end' do
+      let(:value) { { 'min' => now_utc, 'max' => later_utc, 'exclude_end' => true } }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq true
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+
+    context 'when ActiveSupport::TimeWithZone' do
+      let(:value) { now_in_zone..later_in_zone }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq nil
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+
+    context 'when ActiveSupport::TimeWithZone exclude_end' do
+      let(:value) { now_in_zone...later_in_zone }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq true
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, ActiveSupport::TimeWithZone>' do
+      let(:value) { { 'min' => now_in_zone, 'max' => later_in_zone } }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq nil
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+
+    context 'when Hash<String, ActiveSupport::TimeWithZone> exclude_end' do
+      let(:value) { { 'min' => now_in_zone, 'max' => later_in_zone, 'exclude_end' => true } }
+
+      it do
+        expect(subject).to be_a Hash
+        expect(subject['exclude_end']).to eq true
+        expect(subject['min']).to be_within(0.01.second).of(now_utc)
+        expect(subject['max']).to be_within(0.01.second).of(later_utc)
+        expect(subject['min'].class).to eq Time
+        expect(subject['max'].class).to eq Time
+      end
+    end
+  end
+end

data/spec/mongoid/association/counter_cache_spec.rb

@@ -133,7 +133,7 @@ describe Mongoid::Association::Referenced::CounterCache do
       it "expect to raise an error" do
         expect {
           Person.reset_counters "1", :drugs
-        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
     end
 

data/spec/mongoid/association/depending_spec.rb

@@ -73,7 +73,7 @@ describe Mongoid::Association::Depending do
             r = DependentReportCard.create!(dependent_student: s)
             s.destroy!
 
-            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentReportCard with id\(s\)/)
           end
 
           it 'facilitates proper transitive destroying of the object' do
@@ -84,7 +84,7 @@ describe Mongoid::Association::Depending do
             r = DependentReportCard.create!(dependent_student: s)
             s.destroy!
 
-            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentReportCard with id\(s\)/)
           end
 
           it 'adds the dependent to subclasses' do
@@ -105,7 +105,7 @@ describe Mongoid::Association::Depending do
             r = DependentReportCard.create!(dependent_student: s)
             s.destroy!
 
-            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentReportCard with id\(s\)/)
           end
 
           it "doesn't add the dependent to sibling classes" do
@@ -177,7 +177,7 @@ describe Mongoid::Association::Depending do
 
             expect {
               DependentOwnedOne.find(owned.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentOwnedOne with id\(s\)/)
           end
         end
 
@@ -250,7 +250,7 @@ describe Mongoid::Association::Depending do
             dep = Dep.create!(double_assoc: two)
             two.destroy!
 
-            expect { Dep.find(dep.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            expect { Dep.find(dep.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Dep with id\(s\)/)
           end
         end
       end
@@ -362,7 +362,7 @@ describe Mongoid::Association::Depending do
           it "deletes the associated documents" do
             expect {
               child.class.find(child.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class #{child.class.to_s} with id\(s\)/)
           end
         end
 
@@ -674,7 +674,7 @@ describe Mongoid::Association::Depending do
           it "persists the deletion" do
             expect {
               home.reload
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Home with id\(s\)/)
           end
         end
 
@@ -733,13 +733,13 @@ describe Mongoid::Association::Depending do
             it "persists the first deletion" do
               expect {
                 post_one.reload
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
             end
 
             it "persists the second deletion" do
               expect {
                 post_two.reload
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
             end
           end
         end

data/spec/mongoid/association/eager_spec.rb

@@ -244,7 +244,8 @@ describe Mongoid::Association::EagerLoadable do
       end
 
       it "runs the has_one preload" do
-        expect(Mongoid::Association::Referenced::HasOne::Eager).to receive(:new).with([book_association, cat_association], docs).once.and_call_original
+        expect(Mongoid::Association::Referenced::HasOne::Eager).to receive(:new).with([ book_association ], docs).once.and_call_original
+        expect(Mongoid::Association::Referenced::HasOne::Eager).to receive(:new).with([ cat_association ], docs).once.and_call_original
         context.eager_load(docs)
       end
     end

data/spec/mongoid/association/embedded/embedded_in/binding_spec.rb

@@ -58,7 +58,8 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Binding do
         end
 
         it "does nothing" do
-          expect(name).to receive(:namable=).never
+          expect(name).to receive(:namable=).with(person).never
+          expect(name).to receive(:namable=).with(nil).once
           binding.bind_one
         end
       end

data/spec/mongoid/association/embedded/embedded_in/buildable_spec.rb

@@ -33,4 +33,58 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Buildable do
       end
     end
   end
+
+  context 'when the object is already associated with another object' do
+
+    context "when inverse is embeds_many" do
+
+      let(:appointment1) do
+        Appointment.new
+      end
+
+      let(:appointment2) do
+        Appointment.new
+      end
+
+      let(:person) do
+        Person.create!
+      end
+
+      before do
+        appointment1.person = person
+        appointment2.person = person
+      end
+
+      it 'does not clear the object of its previous association' do
+        expect(appointment1.person).to eq(person)
+        expect(appointment2.person).to eq(person)
+        expect(person.appointments).to eq([appointment1, appointment2])
+      end
+    end
+
+    context "when inverse is embeds_one" do
+
+      let(:scribe1) do
+        Scribe.new
+      end
+
+      let(:scribe2) do
+        Scribe.new
+      end
+
+      let(:owner) do
+        Owner.create!
+      end
+
+      before do
+        scribe1.owner = owner
+        scribe2.owner = owner
+      end
+
+      it 'clears the object of its previous association' do
+        expect(scribe1.owner).to be_nil
+        expect(scribe2.owner).to eq(owner)
+      end
+    end
+  end
 end

data/spec/mongoid/association/embedded/embedded_in/proxy_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative '../embeds_many_models'
 
 describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
 
@@ -507,7 +508,7 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     end
   end
 
-  context "when the same class is embedded multiple times" do
+  context "when the same class is embedded multiple times; embeds_one" do
 
     let(:customer) do
       Customer.new
@@ -516,7 +517,6 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     context "assignment after saving" do
 
       it "correctly sets the association for the embedded class" do
-        pending 'MONGOID-5039'
 
         customer.home_address = CustomerAddress.new
         customer.work_address = CustomerAddress.new
@@ -537,22 +537,82 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
 
         expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
         expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+
+        expect(customer.home_address.addressable).to eq(customer)
+        expect(customer.work_address.addressable).to eq(customer)
       end
     end
 
     context "inverse assignment" do
 
+      it "raises an error when trying to set the association" do
+        customer.work_address = CustomerAddress.new
+
+        expect do
+          customer.work_address.addressable = customer
+        end.to raise_error(Mongoid::Errors::InvalidSetPolymorphicRelation)
+      end
+    end
+
+    context "when there is an explicit inverse_of" do
+
+      let(:customer) { EmmCustomer.new }
+
       it "correctly sets the association for the embedded class" do
-        pending 'MONGOID-5039'
+        customer.work_address = EmmCustomerAddress.new
 
-        customer.work_address = CustomerAddress.new
-        customer.work_address.addressable = customer
+        expect do
+          customer.work_address.addressable = customer
+        end.to_not raise_error
 
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
+        expect(customer.work_address.addressable).to eq(customer)
+      end
+    end
+  end
 
-        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
-        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+  context "when the same class is embedded multiple times; embeds_many" do
+
+    let(:customer) do
+      EmmCustomer.new
+    end
+
+    context "assignment after saving" do
+
+      it "correctly sets the association for the embedded class" do
+
+        customer.close_friends = [EmmFriend.new]
+        customer.acquaintances = [EmmFriend.new]
+
+        expect(customer.close_friends._association.store_as).to eq("close_friends")
+        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
+
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+
+        customer.save!
+
+        customer.close_friends = [EmmFriend.new]
+        customer.acquaintances = [EmmFriend.new]
+
+        expect(customer.close_friends._association.store_as).to eq("close_friends")
+        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
+
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+
+        expect(customer.close_friends[0].befriendable).to eq(customer)
+        expect(customer.acquaintances[0].befriendable).to eq(customer)
+      end
+    end
+
+    context "inverse assignment" do
+
+      it "raises an error when trying to set the association" do
+        customer.acquaintances = [EmmFriend.new]
+
+        expect do
+          customer.acquaintances[0].befriendable = customer
+        end.to raise_error(Mongoid::Errors::InvalidSetPolymorphicRelation)
       end
     end
   end