mongoid 7.3.2 → 7.4.0

data/spec/integration/associations/scope_option_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../mongoid/association/referenced/has_and_belongs_to_many_models'
+require_relative '../../mongoid/association/referenced/has_many_models'
+require_relative '../../mongoid/association/referenced/has_one_models'
+
+describe 'association :scope option' do
+
+  context 'has_many and belongs_to' 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!(:animal3) { HmmAnimal.create!(taxonomy: 'mammal', trainer: trainer2) }
+
+    it 'initially associates the documents in-memory' do
+      expect(trainer1.animals).to eq [animal1, animal2]
+      expect(trainer2.animals).to eq [animal3]
+      expect(animal1.trainer).to eq trainer1
+      expect(animal2.trainer).to eq trainer1
+      expect(animal3.trainer).to eq trainer2
+    end
+
+    it 'loads correct documents when queried' do
+      expect(trainer1.reload.animals).to eq [animal1]
+      expect(trainer2.reload.animals).to eq []
+      expect(animal1.reload.trainer).to eq trainer1
+      expect(animal2.reload.trainer).to eq trainer1
+      expect(animal3.reload.trainer).to be_nil
+    end
+
+    it 'eager loads correct documents' do
+      expect(HmmTrainer.includes(:animals).find(trainer1._id).animals).to eq [animal1]
+      expect(HmmTrainer.includes(:animals).find(trainer2._id).animals).to eq []
+      expect(HmmAnimal.includes(:trainer).find(animal1._id).trainer).to eq trainer1
+      expect(HmmAnimal.includes(:trainer).find(animal2._id).trainer).to eq trainer1
+      expect(HmmAnimal.includes(:trainer).find(animal3._id).trainer).to be_nil
+    end
+  end
+
+  context 'has_one and belongs_to' do
+    let!(:trainer1) { HomTrainer.create!(name: 'Dave') }
+    let!(:trainer2) { HomTrainer.create!(name: 'Ash') }
+    let!(:animal1) { HomAnimal.create!(taxonomy: 'reptile', trainer: trainer1) }
+    let!(:animal2) { HomAnimal.create!(taxonomy: 'bird', trainer: trainer1) }
+    let!(:animal3) { HomAnimal.create!(taxonomy: 'mammal', trainer: trainer2) }
+
+    it 'initially associates the documents in-memory' do
+      expect(trainer1.animal).to eq animal2
+      expect(trainer2.animal).to eq animal3
+      expect(animal1.trainer).to eq trainer1
+      expect(animal2.trainer).to eq trainer1
+      expect(animal3.trainer).to eq trainer2
+    end
+
+    it 'loads correct documents when queried' do
+      expect(trainer1.reload.animal).to eq animal1
+      expect(trainer2.reload.animal).to be_nil
+      expect(animal1.reload.trainer).to eq trainer1
+      expect(animal2.reload.trainer).to eq trainer1
+      expect(animal3.reload.trainer).to be_nil
+    end
+
+    it 'eager loads correct documents' do
+      expect(HomTrainer.includes(:animal).find(trainer1._id).animal).to eq animal1
+      expect(HomTrainer.includes(:animal).find(trainer2._id).animal).to be_nil
+      expect(HomAnimal.includes(:trainer).find(animal1._id).trainer).to eq trainer1
+      expect(HomAnimal.includes(:trainer).find(animal2._id).trainer).to eq trainer1
+      expect(HomAnimal.includes(:trainer).find(animal3._id).trainer).to be_nil
+    end
+  end
+
+  context 'has_and_belongs_to_many' 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]) }
+
+    it 'initially associates the documents in-memory' do
+      expect(trainer1.animals).to eq [animal1]
+      expect(trainer2.animals).to eq [animal1]
+      expect(animal1.trainers).to eq [trainer1, trainer2]
+      expect(animal2.trainers).to eq [trainer1, trainer2]
+    end
+
+    it 'loads correct documents when queried' do
+      expect(trainer1.reload.animals).to eq [animal1]
+      expect(trainer2.reload.animals).to eq [animal1]
+      expect(animal1.reload.trainers).to eq [trainer1]
+      expect(animal2.reload.trainers).to eq [trainer1]
+    end
+
+    it 'eager loads correct documents' do
+      expect(HabtmmTrainer.includes(:animals).find(trainer1._id).animals).to eq [animal1]
+      expect(HabtmmTrainer.includes(:animals).find(trainer2._id).animals).to eq [animal1]
+      expect(HabtmmAnimal.includes(:trainers).find(animal1._id).trainers).to eq [trainer1]
+      expect(HabtmmAnimal.includes(:trainers).find(animal2._id).trainers).to eq [trainer1]
+    end
+  end
+end

data/spec/integration/atomic/modifiers_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 

data/spec/integration/bson_regexp_raw_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require 'spec_helper'
 

data/spec/integration/callbacks_models.rb

@@ -47,3 +47,15 @@ class Planet
     self.age ||= 2_000
   end
 end
+
+class Emission
+  include Mongoid::Document
+
+  field :frequency
+
+  after_save do
+    @previous = attribute_was(:frequency)
+  end
+
+  attr_reader :previous
+end

data/spec/integration/callbacks_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require 'spec_helper'
 require_relative './callbacks_models'
@@ -149,7 +148,7 @@ describe 'callbacks integration tests' do
       end
     end
 
-    context 'when updating top-level document via #update_attributes' do
+    context 'when updating top-level document via #update_attributes!' do
       let!(:instance) do
         Galaxy.create!
       end
@@ -167,7 +166,7 @@ describe 'callbacks integration tests' do
 
         context 'set as a document instance' do
           before do
-            instance.update_attributes(stars: [Star.new])
+            instance.update_attributes!(stars: [Star.new])
           end
 
           include_examples 'persists the attribute value'
@@ -175,7 +174,7 @@ describe 'callbacks integration tests' do
 
         context 'set as attributes on parent' do
           before do
-            instance.update_attributes(stars: [{}])
+            instance.update_attributes!(stars: [{}])
           end
 
           include_examples 'persists the attribute value'
@@ -197,7 +196,7 @@ describe 'callbacks integration tests' do
 
         context 'set as a document instance' do
           before do
-            instance.update_attributes(stars: [Star.new(planets: [Planet.new])])
+            instance.update_attributes!(stars: [Star.new(planets: [Planet.new])])
           end
 
           include_examples 'persists the attribute value'
@@ -205,7 +204,7 @@ describe 'callbacks integration tests' do
 
         context 'set as attributes on parent' do
           before do
-            instance.update_attributes(stars: [planets: [{}]])
+            instance.update_attributes!(stars: [planets: [{}]])
           end
 
           include_examples 'persists the attribute value'
@@ -213,4 +212,17 @@ describe 'callbacks integration tests' do
       end
     end
   end
+
+  context 'attribute_was value in after_save callback' do
+    let!(:obj) { Emission.create!(frequency: 1) }
+
+    it 'is set to the new value' do
+      pending 'MONGOID-5104'
+
+      obj.frequency = 2
+      obj.save!
+
+      obj.previous.should == 2
+    end
+  end
 end

data/spec/integration/contextual/empty_spec.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Contextual classes when dealing with empty result set' do
+  shared_examples 'behave as expected' do
+    context '#exists?' do
+      it 'is false' do
+        context.exists?.should be false
+      end
+    end
+
+    context '#count' do
+      it 'is 0' do
+        context.count.should == 0
+      end
+    end
+
+    context '#length' do
+      it 'is 0' do
+        context.length.should == 0
+      end
+    end
+
+    # #estimated_count only exists for Mongo
+
+    context '#distinct' do
+      it 'is empty array' do
+        context.distinct(:foo).should == []
+      end
+    end
+
+    context '#each' do
+      context 'with block' do
+        it 'does not invoke the block' do
+          called = false
+          context.each do
+            called = true
+          end
+          called.should be false
+        end
+      end
+
+      context 'without block' do
+        it 'returns Enumerable' do
+          context.each.should be_a(Enumerable)
+        end
+
+        it 'returns empty Enumerable' do
+          context.each.to_a.should == []
+        end
+      end
+    end
+
+    context '#map' do
+      context 'with block' do
+        it 'does not invoke the block' do
+          called = false
+          context.map do
+            called = true
+          end
+          called.should be false
+        end
+      end
+
+      context 'without block' do
+        it 'returns empty array' do
+          skip 'MONGOID-5148'
+
+          context.map(:field).should == []
+        end
+      end
+    end
+
+    context '#first' do
+      it 'is nil' do
+        context.first.should be nil
+      end
+    end
+
+    context '#find_first' do
+      it 'is nil' do
+        context.find_first.should be nil
+      end
+    end
+
+    context '#one' do
+      it 'is nil' do
+        context.one.should be nil
+      end
+    end
+
+    context '#last' do
+      it 'is nil' do
+        context.last.should be nil
+      end
+    end
+  end
+
+  let(:context) do
+    context_cls.new(criteria)
+  end
+
+  before do
+    # Create an object of the same class used in the Criteria instance
+    # to verify we are using the Contextual classes.
+    Mop.create!
+  end
+
+  context 'Mongo' do
+    let(:context_cls) { Mongoid::Contextual::Mongo }
+
+    let(:criteria) do
+      Mop.and(Mop.where(a: 1), Mop.where(a: 2))
+    end
+
+    include_examples 'behave as expected'
+  end
+
+  context 'Memory' do
+    let(:context_cls) { Mongoid::Contextual::Memory }
+
+    let(:criteria) do
+      Mop.all.tap do |criteria|
+        criteria.documents = []
+      end
+    end
+
+    include_examples 'behave as expected'
+  end
+
+  context 'None' do
+    let(:context_cls) { Mongoid::Contextual::None }
+
+    let(:criteria) do
+      Mop.none
+    end
+
+    include_examples 'behave as expected'
+  end
+end

data/spec/integration/criteria/alias_query_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'distinct on aliased fields' do
+
+  let(:client) { Person.collection.client }
+
+  let(:subscriber) do
+    Mrss::EventSubscriber.new
+  end
+
+  before do
+    client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  after do
+    client.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  let(:event) do
+    subscriber.single_command_started_event('distinct')
+  end
+
+  let(:command) { event.command }
+
+  context 'when broken_alias_handling is not set' do
+    config_override :broken_alias_handling, false
+
+    context 'top level field' do
+      let(:query) do
+        Person.distinct(:test)
+      end
+
+      it 'expands the alias' do
+        query
+
+        command['key'].should == 't'
+      end
+    end
+
+    context 'embedded document field' do
+      let(:query) do
+        Person.distinct('phone_numbers.extension')
+      end
+
+      it 'expands the alias' do
+        query
+
+        command['key'].should == 'phone_numbers.ext'
+      end
+    end
+  end
+
+  context 'when broken_alias_handling is set' do
+    config_override :broken_alias_handling, true
+
+    context 'top level field' do
+      let(:query) do
+        Person.distinct(:test)
+      end
+
+      it 'expands the alias' do
+        query
+
+        command['key'].should == 't'
+      end
+    end
+
+    context 'embedded document field' do
+      let(:query) do
+        Person.distinct('phone_numbers.extension')
+      end
+
+      it 'deos not expands the alias' do
+        query
+
+        command['key'].should == 'phone_numbers.extension'
+      end
+    end
+  end
+end
+
+describe 'pluck on aliased fields' do
+
+  let(:client) { Person.collection.client }
+
+  let(:subscriber) do
+    Mrss::EventSubscriber.new
+  end
+
+  before do
+    client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  after do
+    client.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  let(:event) do
+    subscriber.single_command_started_event('find')
+  end
+
+  let(:command) { event.command }
+
+  context 'when broken_alias_handling is not set' do
+    config_override :broken_alias_handling, false
+
+    context 'top level field' do
+      let(:query) do
+        Person.pluck(:test)
+      end
+
+      it 'expands the alias' do
+        query
+
+        command['projection'].should == {'t' => true}
+      end
+    end
+
+    context 'embedded document field' do
+      let(:query) do
+        Person.pluck('phone_numbers.extension')
+      end
+
+      it 'expands the alias' do
+        query
+
+        command['projection'].should == {'phone_numbers.ext' => true}
+      end
+    end
+  end
+
+  context 'when broken_alias_handling is set' do
+    config_override :broken_alias_handling, true
+
+    context 'top level field' do
+      let(:query) do
+        Person.pluck(:test)
+      end
+
+      it 'expands the alias' do
+        query
+
+        command['projection'].should == {'t' => true}
+      end
+    end
+
+    context 'embedded document field' do
+      let(:query) do
+        Person.pluck('phone_numbers.extension')
+      end
+
+      it 'does not expand the alias' do
+        query
+
+        command['projection'].should == {'phone_numbers.extension' => true}
+      end
+    end
+  end
+end

data/spec/integration/criteria/date_field_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require 'spec_helper'
 

data/spec/integration/criteria/default_scope_spec.rb

@@ -18,4 +18,55 @@ describe 'Criteria and default scope' do
       sort_options.keys.should == %w(name status)
     end
   end
+
+  context 'default scope + logical operator' do
+
+    context 'logical operator applied to a criteria' do
+      let(:base) { Appointment.where }
+
+      it 'has default scope' do
+        base.selector.should == {'active' => true}
+      end
+
+      context '.or' do
+        let(:criteria) do
+          base.or(timed: true)
+        end
+
+        it 'adds new condition in parallel to default scope conditions' do
+          criteria.selector.should == {'$or' => [
+            {'active' => true},
+            {'timed' => true},
+          ]}
+        end
+      end
+
+      context '.any_of' do
+        let(:criteria) do
+          base.any_of(timed: true)
+        end
+
+        it 'maintains default scope conditions' do
+          criteria.selector.should == {'active' => true, 'timed' => true}
+        end
+      end
+    end
+
+    context 'logical operator called on the class' do
+      let(:base) { Appointment }
+
+      context '.or' do
+        let(:criteria) do
+          base.or(timed: true)
+        end
+
+        it 'adds new condition in parallel to default scope conditions' do
+          criteria.selector.should == {'$or' => [
+            {'active' => true},
+            {'timed' => true},
+          ]}
+        end
+      end
+    end
+  end
 end

data/spec/integration/criteria/logical_spec.rb

@@ -25,6 +25,36 @@ describe 'Criteria logical operations' do
       bands = Band.where(name: /Proj/).and(Band.where(name: /u/))
       expect(bands.to_a).to eq([sp])
     end
+
+    context "when broken_and feature flag is not set" do
+      config_override :broken_and, false
+
+      it 'combines existing `$and` clause in query and `where` condition' do
+        bands = Band.where(id: 1).and({year: {'$in' => [2020]}}, {year: {'$in' => [2021]}}).where(id: 2)
+        expect(bands.selector).to eq(
+          {
+            "_id"=>1,
+            "year"=>{"$in"=>[2020]},
+            "$and"=>[{"year"=>{"$in"=>[2021]}}, {"_id"=>2}]
+          }
+        )
+      end
+    end
+
+    context "when broken_and feature flag is set" do
+      config_override :broken_and, true
+
+      it 'combines existing `$and` clause in query and `where` condition' do
+        bands = Band.where(id: 1).and({year: {'$in' => [2020]}}, {year: {'$in' => [2021]}}).where(id: 2)
+        expect(bands.selector).to eq(
+          {
+            "_id"=>1,
+            "year"=>{"$in"=>[2020]},
+            "$and"=>[{"_id"=>2}]
+          }
+        )
+      end
+    end
   end
 
   describe 'or' do