mongoid 7.5.4 → 8.1.9

data/spec/integration/callbacks_spec.rb

@@ -188,8 +188,6 @@ describe 'callbacks integration tests' do
           end
 
           it 'persists the attribute value' do
-            pending 'MONGOID-4476'
-
             Galaxy.find(instance.id).stars.first.planets.first.age.should == 2_000
           end
         end
@@ -211,18 +209,397 @@ describe 'callbacks integration tests' do
         end
       end
     end
+
+    context 'when updating top-level embeds_one document via #update_attributes!' do
+      let!(:instance) do
+        Country.create!
+      end
+
+      context 'embedded document' do
+        shared_examples 'persists the attribute value' do
+          it 'writes the attribute value into the model' do
+            instance.president.age.should == 79
+          end
+
+          it 'persists the attribute value' do
+            Country.find(instance.id).president.age.should == 79
+          end
+        end
+
+        context 'set as a document instance' do
+          before do
+            instance.update_attributes!(president: President.new)
+          end
+
+          include_examples 'persists the attribute value'
+        end
+
+        context 'set as attributes on parent' do
+          before do
+            instance.update_attributes!(president: { name: "Abraham Lincoln" })
+          end
+
+          include_examples 'persists the attribute value'
+        end
+      end
+
+      context 'nested embedded document' do
+        shared_examples 'persists the attribute value' do
+          it 'writes the attribute value into the model' do
+            instance.president.first_spouse.age.should == 70
+          end
+
+          it 'persists the attribute value' do
+            Country.find(instance.id).president.first_spouse.age.should == 70
+          end
+        end
+
+        context 'set as a document instance' do
+          before do
+            instance.update_attributes!(president: President.new(first_spouse: FirstSpouse.new))
+          end
+
+          include_examples 'persists the attribute value'
+        end
+
+        context 'set as attributes on parent' do
+          before do
+            instance.update_attributes!(president: { first_spouse: { name: "Mary Todd Lincoln" } })
+          end
+
+          include_examples 'persists the attribute value'
+        end
+      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
+
+  context 'atomic_selector in after_save callback' do
+    let(:name) do
+      'Alice'
+    end
+
+    let(:new_name) do
+      'Bob'
+    end
+
+    class CBIntSpecProfile
+      include Mongoid::Document
+      field :name, type: String
+      shard_key :name
+
+      attr_reader :atomic_selector_in_after_save
+
+      after_save do |document|
+        @atomic_selector_in_after_save = document.atomic_selector
+      end
+    end
+
+    it 'has updated attributes' do
+      profile = CBIntSpecProfile.create!(name: name)
+      profile.name = new_name
+      profile.save!
+      expect(
+        profile.atomic_selector_in_after_save['name']
+      ).to eq(new_name)
+    end
+  end
+
+  context "When touching an embedded document" do
+    let(:planet) { Planet.new }
+    let(:star) { Star.new }
+    let(:galaxy) { Galaxy.create! }
+
+    before do
+      star.planets << planet
+      galaxy.stars << star
+    end
+
+    it "the parent document touch callback gets called before the child" do
+      planet.touch
+      expect(galaxy.was_touched).to be true
+      expect(star.was_touched_after_parent).to be true
+      expect(planet.was_touched_after_parent).to be true
+    end
+  end
+
+  context "when reloading has_and_belongs_to_many after_save and after_remove callbacks" do
+
+    let(:architect) { Architect.create }
+
+    let(:b1) { Building.create }
+
+    let(:b2) { Building.create }
+
+    let(:b3) { Building.create }
+
+    it "counts added/removed buildings correctly" do
+      architect.buildings << b1
+      expect(architect.after_add_num_buildings).to eq(1)
+
+      architect.reload
+      architect.buildings << b2
+      expect(architect.after_add_num_buildings).to eq(2)
+
+      architect.reload
+      architect.buildings << b3
+      expect(architect.after_add_num_buildings).to eq(3)
+
+      architect.reload
+      architect.buildings.delete(b3)
+      expect(architect.after_remove_num_buildings).to eq(2)
+    end
+  end
+
+  context '_previously was methods in after_save callback' do
+    let(:title) do
+      "Title"
+    end
+
+    let(:updated_title) do
+      "Updated title"
+    end
+
+    let(:age) do
+      10
+    end
+
+    it do
+      class PreviouslyWasPerson
+        include Mongoid::Document
+
+        field :title, type: String
+        field :age, type: Integer
+
+        attr_reader :after_save_vals
+
+        set_callback :save, :after do |doc|
+          @after_save_vals ||= []
+          @after_save_vals << [doc.title_previously_was, doc.age_previously_was]
+        end
+      end
+
+      person = PreviouslyWasPerson.create!(title: title, age: age)
+      person.title = updated_title
+      person.save!
+      expect(person.after_save_vals).to eq([
+        # Field values are nil before create
+        [nil, nil],
+        [title, age]
+        ])
+    end
+  end
+
+  context 'previously_new_record? in after_save' do
+    it do
+      class PreviouslyNewRecordPerson
+        include Mongoid::Document
+
+        field :title, type: String
+        field :age, type: Integer
+
+        attr_reader :previously_new_record_value
+
+        set_callback :save, :after do |doc|
+          @previously_new_record_value = doc.previously_new_record?
+        end
+      end
+
+      person = PreviouslyNewRecordPerson.create!(title: "title", age: 55)
+      expect(person.previously_new_record_value).to be_truthy
+      person.title = "New title"
+      person.save!
+      expect(person.previously_new_record_value).to be_falsey
+    end
+  end
+
+  context 'previously_persisted? in after_destroy' do
+    it do
+      class PreviouslyPersistedPerson
+        include Mongoid::Document
+
+        field :title, type: String
+        field :age, type: Integer
+
+        attr_reader :previously_persisted_value
+
+        set_callback :destroy, :after do |doc|
+          @previously_persisted_value = doc.previously_persisted?
+        end
+      end
+
+      unsaved_person = PreviouslyPersistedPerson.new(title: "title", age: 55)
+      unsaved_person.destroy
+      expect(unsaved_person.previously_persisted_value).to be_falsey
+
+      saved_person = PreviouslyPersistedPerson.create(title: "title", age: 55)
+      saved_person.destroy
+      expect(saved_person.previously_persisted_value).to be_truthy
+    end
+  end
+
+  context 'saved_change_to_attribute, attribute_before_last_save, will_save_change_to_attribute' do
+    class TestSCTAAndABLSInCallbacks
+      include Mongoid::Document
+
+      field :name, type: String
+      field :age, type: Integer
+
+      set_callback :save, :before do |doc|
+        [:name, :age].each do |attr|
+          saved_change_to_attribute_values_before[attr] += [saved_change_to_attribute(attr)]
+          attribute_before_last_save_values_before[attr] += [attribute_before_last_save(attr)]
+          will_save_change_to_attribute_values_before[attr] += [will_save_change_to_attribute?(attr)]
+        end
+      end
+
+      set_callback :save, :after do |doc|
+        [:name, :age].each do |attr|
+          saved_change_to_attribute_values_after[attr] += [saved_change_to_attribute(attr)]
+          saved_change_to_attribute_q_values_after[attr] += [saved_change_to_attribute?(attr)]
+          attribute_before_last_save_values_after[attr] += [attribute_before_last_save(attr)]
+        end
+      end
+
+      def saved_change_to_attribute_values_before
+        @saved_change_to_attribute_values_before ||= Hash.new do
+          []
+        end
+      end
+
+      def attribute_before_last_save_values_before
+        @attribute_before_last_save_values_before ||= Hash.new do
+          []
+        end
+      end
+
+      def saved_change_to_attribute_values_after
+        @saved_change_to_attribute_values_after ||= Hash.new do
+          []
+        end
+      end
+
+      def saved_change_to_attribute_q_values_after
+        @saved_change_to_attribute_q_values_after ||= Hash.new do
+          []
+        end
+      end
+
+      def attribute_before_last_save_values_after
+        @attribute_before_last_save_values_after ||= Hash.new do
+          []
+        end
+      end
+
+      def will_save_change_to_attribute_values_before
+        @will_save_change_to_attribute_values_before ||= Hash.new do
+          []
+        end
+      end
+    end
+
+    it 'reproduces ActiveRecord::AttributeMethods::Dirty behavior' do
+      subject = TestSCTAAndABLSInCallbacks.new(name: 'Name 1')
+      subject.save!
+      subject.age = 18
+      subject.save!
+      subject.name = 'Name 2'
+      subject.save!
+
+      expect(subject.saved_change_to_attribute_values_before).to eq(
+        {
+          :name => [nil, [nil, "Name 1"], nil],
+          :age => [nil, nil, [nil, 18]],
+        }
+      )
+      expect(subject.saved_change_to_attribute_values_after).to eq(
+        {
+          :name => [[nil, "Name 1"], nil, ["Name 1", "Name 2"]],
+          :age => [nil, [nil, 18], nil],
+        }
+      )
+      expect(subject.saved_change_to_attribute_q_values_after).to eq(
+        {
+          :name => [true, false, true],
+          :age => [false, true, false],
+        }
+      )
+      expect(subject.attribute_before_last_save_values_before).to eq(
+        {
+          :name => [nil, nil, "Name 1"],
+          :age => [nil, nil, nil]
+        }
+      )
+      expect(subject.attribute_before_last_save_values_after).to eq(
+        {
+          :name => [nil, "Name 1", "Name 1"],
+          :age => [nil, nil, 18]
+        }
+      )
+      expect(subject.will_save_change_to_attribute_values_before).to eq(
+        {
+          :name => [true, false, true],
+          :age => [false, true, false]
+        }
+      )
+    end
+  end
+
+  context 'nested embedded documents' do
+    config_override :prevent_multiple_calls_of_embedded_callbacks, true
+    config_override :around_callbacks_for_embeds, true
+
+    let(:logger) { Array.new }
+
+    let(:root) do
+      Root.new(
+        embedded_once: [
+          EmbeddedOnce.new(
+            embedded_twice: [EmbeddedTwice.new]
+          )
+        ]
+      )
+    end
+
+    before(:each) do
+      root.logger = logger
+      root.embedded_once.first.logger = logger
+      root.embedded_once.first.embedded_twice.first.logger = logger
+    end
+
+    it 'runs callbacks in the correct order' do
+      root.save!
+      expect(logger).to eq(%i[embedded_twice embedded_once root])
+    end
+  end
+
+  context 'cascade callbacks' do
+    ruby_version_gte '3.0'
+    config_override :around_callbacks_for_embeds, false
+
+    let(:book) do
+      Book.new
+    end
+
+    before do
+      1500.times do
+        book.pages.build
+      end
+    end
+
+    # https://jira.mongodb.org/browse/MONGOID-5658
+    it 'does not raise SystemStackError' do
+      expect { book.save! }.not_to raise_error(SystemStackError)
+    end
+  end
 end

data/spec/integration/criteria/range_spec.rb

@@ -7,11 +7,15 @@ describe 'Queries with Range criteria' do
   let(:now_in_zone) { now_utc.in_time_zone('Asia/Tokyo') }
   let(:today) { Date.new(2020, 1, 1) }
 
+  let(:labels) do
+    [ Label.new(age: 12), Label.new(age: 16) ]
+  end
+
   let!(:band1) { Band.create!(likes: 0, rating: 0.9, founded: today, updated_at: now_utc) }
   let!(:band2) { Band.create!(likes: 1, rating: 1.0, founded: today + 1.day, updated_at: now_utc + 1.days) }
   let!(:band3) { Band.create!(likes: 2, rating: 2.9, founded: today + 2.days, updated_at: now_utc + 2.days) }
   let!(:band4) { Band.create!(likes: 3, rating: 3.0, founded: today + 3.days, updated_at: now_utc + 3.days) }
-  let!(:band5) { Band.create!(likes: 4, rating: 3.1, founded: today + 4.days, updated_at: now_utc + 4.days) }
+  let!(:band5) { Band.create!(likes: 4, rating: 3.1, founded: today + 4.days, updated_at: now_utc + 4.days, labels: labels) }
 
   context 'Range<Integer> criteria vs Integer field' do
 
@@ -262,4 +266,94 @@ describe 'Queries with Range criteria' do
       end
     end
   end
+
+  context 'Range<Integer> criteria vs embedded Integer field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where("labels.age" => 10..18).to_a).to eq [band5]
+      expect(Band.where("labels.age" => 13...16).to_a).to eq []
+    end
+
+    it "does not return objects out of range" do
+      expect(Band.where("labels.age" => 13..14).to_a).to eq []
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where("labels.age": eval('1..')).to_a).to eq [band5]
+      end
+
+      it 'does not return the objects under the value' do
+        expect(Band.where("labels.age": eval('100..')).to_a).to eq []
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where("labels.age": eval('..16')).to_a).to eq [band5]
+      end
+      it 'does not return the objects above the value' do
+        expect(Band.where("labels.age": eval('...12')).to_a).to eq []
+      end
+    end
+  end
+
+  context 'Range<Integer> criteria vs Array<Integer>' do
+    let!(:band6) { Band.create!(genres: [12, 16]) }
+
+    it 'returns objects within the range' do
+      expect(Band.where("genres" => 10..18).to_a).to eq [band6]
+    end
+
+    it "does not return objects out of range" do
+      expect(Band.where("genres" => 13..14).to_a).to eq []
+    end
+  end
+
+  context 'Range<Integer> criteria vs aliased Array<Integer>' do
+    let!(:person) { Person.create!(array: [12, 16]) }
+
+    it 'returns objects within the range' do
+      expect(Person.where("array" => 10..18).to_a).to eq [person]
+    end
+
+    it "does not return objects out of range" do
+      expect(Person.where("array" => 13..14).to_a).to eq []
+    end
+  end
+
+  context 'Range<Integer> criteria vs Array<Hash<Symbol, Integer>>' do
+    let!(:band6) { Band.create!(genres: [{x: 12}, {x: 16}]) }
+
+    it 'returns objects within the range' do
+      expect(Band.where("genres.x" => 10..18).to_a).to eq [band6]
+    end
+
+    it "does not return objects out of range" do
+      expect(Band.where("genres.x" => 13..14).to_a).to eq []
+    end
+  end
+
+  context 'Range<Integer> criteria vs aliased/doubly embedded Integer' do
+    let!(:person) do
+      Person.create!(passport: Passport.new).tap do |b|
+        b.passport.passport_pages.create!(num_stamps: 12)
+        b.passport.passport_pages.create!(num_stamps: 16)
+      end
+    end
+
+    config_override :broken_alias_handling, false
+
+    it 'returns objects within the range' do
+      expect(Person.where("passport.passport_pages.num_stamps" => 10..18).to_a).to eq [person]
+    end
+
+    it "does not return objects out of range" do
+      expect(Person.where("passport.passport_pages.num_stamps" => 13..14).to_a).to eq []
+    end
+  end
 end