mongoid 7.5.0 → 8.0.1

data/spec/integration/i18n_fallbacks_spec.rb

@@ -23,10 +23,6 @@ describe 'i18n fallbacks' do
       I18n.fallbacks[:de] = [ :en ]
     end
 
-    after do
-      I18n.locale = :en
-    end
-
     context 'when translation is present in active locale' do
       it 'uses active locale' do
         product = Product.new
@@ -40,9 +36,6 @@ describe 'i18n fallbacks' do
     end
 
     context 'when translation is missing in active locale and present in fallback locale' do
-      after do
-        I18n.locale = :en
-      end
 
       it 'falls back on default locale' do
         product = Product.new
@@ -64,10 +57,6 @@ describe 'i18n fallbacks' do
           end
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         it 'returns nil' do
           product = Product.new
           I18n.locale = :en
@@ -86,10 +75,6 @@ describe 'i18n fallbacks' do
           end
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         it 'falls back on default locale' do
           product = Product.new
           I18n.locale = :en
@@ -97,6 +82,7 @@ describe 'i18n fallbacks' do
           I18n.locale = :ru
           product.description.should == 'Marvelous!'
         end
+
       end
     end
   end

data/spec/integration/matcher_examples_spec.rb

@@ -652,10 +652,12 @@ describe 'Matcher' do
 
     describe 'range match on array element' do
 
+      let(:record) do
+        Record.new(producers: [123, 456])
+      end
+
       let!(:band) do
-        Band.create!(records: [
-          Record.new(producers: [123, 456]),
-        ])
+        Band.create!(records: [ record ])
       end
 
       describe 'MongoDB query' do
@@ -667,14 +669,13 @@ describe 'Matcher' do
           expect(found_band).to eq(band)
         end
 
-        # https://jira.mongodb.org/browse/MONGOID-4911
         context 'no match' do
 
-        let!(:band) do
-          Band.create!(records: [
-            Record.new(producers: [50]),
-          ])
-        end
+          let!(:band) do
+            Band.create!(records: [
+              Record.new(producers: [50, 250]),
+            ])
+          end
 
           it 'does not find' do
             expect(found_band).to be nil
@@ -687,10 +688,16 @@ describe 'Matcher' do
           band.records.where(producers: 100..200).first
         end
 
-        it 'raises InvalidQuery' do
-          lambda do
-            found_record
-          end.should raise_error(Mongoid::Errors::InvalidQuery)
+        let(:no_record) do
+          band.records.where(producers: 199..200).first
+        end
+
+        it 'finds correctly' do
+          expect(found_record).to eq(record)
+        end
+
+        it "correctly does not find" do
+          expect(no_record).to eq(nil)
         end
       end
     end

data/spec/integration/matcher_operator_data/type_decimal.yml

@@ -29,12 +29,13 @@
   matches: false
   min_server_version: 3.4
 
-- name: BigDecimal field - does not match
+# Requires :map_big_decimal_to_decimal128 option to be true.
+- name: BigDecimal field - matches
   document:
     big_decimal_field: !ruby/object:BigDecimal
       18:0.42e2
   query:
     big_decimal_field:
       $type: 19
-  matches: false
+  matches: true
   min_server_version: 3.4

data/spec/integration/matcher_operator_spec.rb

@@ -12,6 +12,8 @@ def mop_error?(spec, kind)
 end
 
 describe 'Matcher operators' do
+  config_override :map_big_decimal_to_decimal128, true
+
   Dir[File.join(File.dirname(__FILE__), 'matcher_operator_data', '*.yml')].sort.each do |path|
     context File.basename(path) do
       permitted_classes = [ BigDecimal,
@@ -35,11 +37,7 @@ describe 'Matcher operators' do
                             BSON::Timestamp,
                             BSON::Undefined ]
 
-      specs = if RUBY_VERSION.start_with?("2.5")
-                YAML.safe_load(File.read(path), permitted_classes, [], true)
-              else
-                YAML.safe_load(File.read(path), permitted_classes: permitted_classes, aliases: true)
-              end
+      specs = YAML.safe_load(File.read(path), permitted_classes: permitted_classes, aliases: true)
 
       specs.each do |spec|
         context spec['name'] do

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