mongoid 7.0.12 → 7.3.3

data/spec/mongoid/persistable/renamable_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Renamable do
@@ -131,5 +134,19 @@ describe Mongoid::Persistable::Renamable do
         it_behaves_like "a renamable embedded document"
       end
     end
+
+    context "when executing atomically" do
+
+      let(:person) do
+        Person.create(title: "sir")
+      end
+
+      it "marks a dirty change for the renamed fields" do
+        person.atomically do
+          person.rename title: :salutation
+          expect(person.changes).to eq({"title" => ["sir", nil], "salutation" => [nil, "sir"]})
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/savable_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Savable do
@@ -162,35 +165,35 @@ describe Mongoid::Persistable::Savable do
 
       context "when performing modification and insert ops" do
 
-        let(:person) do
-          Person.create(title: "Blah")
+        let(:owner) do
+          Owner.create(name: "Blah")
         end
 
-        let!(:address) do
-          person.addresses.build(street: "Bond St")
+        let!(:birthday) do
+          owner.birthdays.build(title: "First")
         end
 
-        let!(:name) do
-          person.create_name(first_name: "Tony")
+        let!(:scribe) do
+          owner.create_scribe(name: "Josh")
         end
 
         let(:from_db) do
-          Person.find(person.id)
+          Owner.find(owner.id)
         end
 
         before do
-          person.title = "King"
-          name.first_name = "Ryan"
+          owner.name = "King"
+          scribe.name = "Tosh"
         end
 
         it "persists with proper set and push modifiers" do
-          expect(person.atomic_updates).to eq({
+          expect(owner.atomic_updates).to eq({
             "$set" => {
-              "title" => "King",
-              "name.first_name" => "Ryan"
+              "name" => "King",
+              "scribe.name" => "Tosh"
             },
             "$push"=> {
-              "addresses" => { '$each' => [ { "_id" => address.id, "street" => "Bond St" } ] }
+              "birthdays" => { '$each' => [ { "_id" => birthday.id, "title" => "First" } ] }
             }
           })
         end
@@ -198,15 +201,15 @@ describe Mongoid::Persistable::Savable do
         context "when saving the document" do
 
           it "saves the root document" do
-            expect(person.title).to eq("King")
+            expect(owner.name).to eq("King")
           end
 
           it "saves embedded many relations" do
-            expect(person.addresses.first.street).to eq("Bond St")
+            expect(owner.birthdays.first.title).to eq("First")
           end
 
           it "saves embedded one relations" do
-            expect(person.name.first_name).to eq("Ryan")
+            expect(owner.scribe.name).to eq("Tosh")
           end
         end
       end
@@ -255,6 +258,162 @@ describe Mongoid::Persistable::Savable do
         end
       end
 
+      context 'when adding documents to embedded associations on multiple levels' do
+        let!(:truck) { Truck.create! }
+        let!(:crate) { truck.crates.create!(volume: 0.4) }
+
+        it 'persists the new documents' do
+          expect(truck.crates.size).to eq 1
+          expect(truck.crates[0].volume).to eq 0.4
+          expect(truck.crates[0].toys.size).to eq 0
+
+          truck.crates.first.toys.build(name: "Teddy bear")
+          truck.crates.build(volume: 0.8)
+
+          # The following is equivalent to the two lines above:
+          #
+          # truck.crates_attributes = {
+          #   '0' => {
+          #     "toys_attributes" => {
+          #       "0" => {
+          #         "name" => "Teddy bear"
+          #       }
+          #     },
+          #     "id" => crate.id.to_s
+          #   },
+          #   "1" => {
+          #     "volume" => 0.8
+          #   }
+          # }
+
+          expect(truck.crates.size).to eq 2
+          expect(truck.crates[0].volume).to eq 0.4
+          expect(truck.crates[0].toys.size).to eq 1
+          expect(truck.crates[0].toys[0].name).to eq "Teddy bear"
+          expect(truck.crates[1].volume).to eq 0.8
+          expect(truck.crates[1].toys.size).to eq 0
+
+          # TODO: MONGOID-5026: combine the updates so that there are
+          # no conflicts.
+          #expect(truck.atomic_updates[:conflicts]).to eq nil
+
+          expect { truck.save! }.not_to raise_error
+
+          _truck = Truck.find(truck.id)
+          expect(_truck.crates.size).to eq 2
+          expect(_truck.crates[0].volume).to eq 0.4
+          expect(_truck.crates[0].toys.size).to eq 1
+          expect(_truck.crates[0].toys[0].name).to eq "Teddy bear"
+          expect(_truck.crates[1].volume).to eq 0.8
+          expect(_truck.crates[1].toys.size).to eq 0
+        end
+      end
+
+      context 'when adding documents to embedded association and updating parent fields' do
+        let!(:truck) { Truck.create! }
+        let!(:crate) { truck.crates.create!(volume: 0.4) }
+
+        it 'performs all writes' do
+          truck.crates.build(volume: 1)
+          truck.crates.first.volume = 2
+
+          truck.save!
+
+          _truck = Truck.find(truck.id)
+          _truck.crates.length.should == 2
+          _truck.crates.first.volume.should == 2
+          _truck.crates.last.volume.should == 1
+        end
+      end
+
+      context 'when adding documents to nested embedded association and updating first association fields' do
+        let!(:truck) { Truck.create! }
+        let!(:seat) { truck.seats.create!(rating: 1) }
+
+        it 'performs all writes' do
+          truck.seats.first.armrests.build(side: 'left')
+          truck.seats.first.rating = 2
+
+          truck.save!
+
+          _truck = Truck.find(truck.id)
+          _truck.seats.length.should == 1
+          _truck.seats.first.armrests.length.should == 1
+          _truck.seats.first.armrests.first.side.should == 'left'
+        end
+      end
+
+      context 'when adding documents to nested embedded association and adding another top level association' do
+        let!(:truck) { Truck.create! }
+        let!(:crate) { truck.crates.create!(volume: 1) }
+
+        it 'performs all writes' do
+          truck.crates.first.toys.build(name: 'Bear')
+          truck.crates.build
+
+          truck.save!
+
+          _truck = Truck.find(truck.id)
+          _truck.crates.length.should == 2
+          _truck.crates.first.toys.length.should == 1
+          _truck.crates.first.toys.first.name.should == 'Bear'
+          _truck.crates.last.toys.length.should == 0
+        end
+
+        context 'when also updating first embedded top level association' do
+          it 'performs all writes' do
+            truck.crates.first.volume = 2
+            truck.crates.first.toys.build(name: 'Bear')
+            truck.crates.build
+
+            truck.save!
+
+            _truck = Truck.find(truck.id)
+            _truck.crates.length.should == 2
+            _truck.crates.first.toys.length.should == 1
+            _truck.crates.first.toys.first.name.should == 'Bear'
+            _truck.crates.last.toys.length.should == 0
+          end
+        end
+      end
+
+      context 'when adding documents to embedded associations with cascaded callbacks on update' do
+        let!(:truck) { Truck.create! }
+        let!(:seat) { truck.seats.create!(rating: 1) }
+
+        it 'persists the new documents' do
+          expect(truck.seats.size).to eq 1
+          expect(truck.seats[0].rating).to eq 1
+
+          truck.seats.build
+
+          expect { truck.save! }.not_to raise_error
+
+          _truck = Truck.find(truck.id)
+          expect(_truck.seats.size).to eq 2
+          expect(_truck.seats[0].rating).to eq 1
+          expect(_truck.seats[1].rating).to eq 100
+        end
+
+        context 'when embedded association embeds another association' do
+          it 'persists the new documents' do
+            expect(truck.seats.size).to eq 1
+            expect(truck.seats[0].rating).to eq 1
+
+            truck.seats.first.armrests.build
+            truck.seats.build
+
+            expect { truck.save! }.not_to raise_error
+
+            _truck = Truck.find(truck.id)
+            expect(_truck.seats.size).to eq 2
+            expect(_truck.seats[0].rating).to eq 2
+            expect(_truck.seats[0].armrests.length).to eq 1
+            expect(_truck.seats[1].rating).to eq 100
+          end
+        end
+      end
+
       context "when removing elements without using delete or destroy" do
 
         let!(:person) do

data/spec/mongoid/persistable/settable_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Settable do
@@ -164,6 +167,20 @@ describe Mongoid::Persistable::Settable do
         end
       end
     end
+
+    context "when executing atomically" do
+
+      let(:person) do
+        Person.create(title: "sir", age: 30)
+      end
+
+      it "marks a dirty change for the set fields" do
+        person.atomically do
+          person.set title: "miss", age: 21
+          expect(person.changes).to eq({"title" => ["sir", "miss"], "age" => [30, 21]})
+        end
+      end
+    end
   end
 
   context "when dynamic attributes are not enabled" do
@@ -495,4 +512,34 @@ describe Mongoid::Persistable::Settable do
       end
     end
   end
+
+  context "when the field being set was projected out" do
+    let(:full_agent) do
+      Agent.create!(title: "Double-Oh Eight")
+    end
+
+    let(:agent) do
+      Agent.where(_id: full_agent.id).only(:dob).first
+    end
+
+    context 'field exists in database' do
+      it "raises MissingAttributeError" do
+        lambda do
+          agent.set(title: '008')
+        end.should raise_error(ActiveModel::MissingAttributeError)
+
+        expect(agent.reload.title).to eq 'Double-Oh Eight'
+      end
+    end
+
+    context 'field does not exist in database' do
+      it "raises MissingAttributeError" do
+        lambda do
+          agent.set(number: '008')
+        end.should raise_error(ActiveModel::MissingAttributeError)
+
+        expect(agent.reload.read_attribute(:number)).to be nil
+      end
+    end
+  end
 end

data/spec/mongoid/persistable/unsettable_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Unsettable do
@@ -151,5 +154,19 @@ describe Mongoid::Persistable::Unsettable do
         it_behaves_like "an unsettable embedded document"
       end
     end
+
+    context "when executing atomically" do
+
+      let(:person) do
+        Person.create(title: "sir", age: 30)
+      end
+
+      it "marks a dirty change for the unset fields" do
+        person.atomically do
+          person.unset :title
+          expect(person.changes).to eq({"title" => ["sir", nil]})
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/updatable_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Updatable do
@@ -455,6 +458,7 @@ describe Mongoid::Persistable::Updatable do
     describe "##{method}" do
 
       context "when saving with a hash field with invalid keys" do
+        max_server_version '4.9'
 
         let(:person) do
           Person.create
@@ -491,6 +495,7 @@ describe Mongoid::Persistable::Updatable do
       end
 
       context "when the document has been destroyed" do
+        max_server_version '4.9'
 
         let(:person) do
           Person.create

data/spec/mongoid/persistable/upsertable_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Upsertable do
@@ -29,7 +32,7 @@ describe Mongoid::Persistable::Upsertable do
     context "when the document is new" do
 
       let!(:existing) do
-        Band.create(name: "Photek")
+        Band.create!(name: "Photek")
       end
 
       context "when a matching document exists in the db" do

data/spec/mongoid/persistable_spec.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Persistable do
 
+  class PersistableSpecTestException < StandardError; end
+
   describe "#atomically" do
 
     let(:document) do
@@ -173,8 +178,8 @@ describe Mongoid::Persistable do
 
         before do
           class Band
-            def my_updates
-              atomically do |d|
+            def my_updates(**args)
+              atomically(**args) do |d|
                 d.set(name: "Placebo")
                 d.unset(:origin)
               end
@@ -182,15 +187,87 @@ describe Mongoid::Persistable do
           end
         end
 
-        let!(:update) do
-          document.atomically do |doc|
-            doc.inc(member_count: 10)
-            doc.bit(likes: { and: 13 })
-            doc.my_updates
+        context "when given join_context: false" do
+
+          let(:run_update) do
+            document.atomically do |doc|
+              doc.set origin: "Paris"
+              doc.atomically(join_context: false) do |doc2|
+                doc2.inc(member_count: 10)
+              end
+              doc.inc likes: 1
+              raise PersistableSpecTestException, "oops"
+            end
+          end
+
+          it_behaves_like "an atomically updatable root document" do
+            let!(:update) do
+              document.atomically do |doc|
+                doc.inc(member_count: 10)
+                doc.my_updates join_context: false
+                doc.bit(likes: { and: 13 })
+              end
+            end
+          end
+
+          it "independently persists the non-joining block's operations" do
+            begin run_update; rescue PersistableSpecTestException; end
+
+            document.reload
+
+            expect(document.origin).to eq "London"
+            expect(document.likes).to eq 60
+            expect(document.member_count).to eq 10
+          end
+
+          it "resets in-memory changes that did not successfully persist" do
+            begin run_update; rescue PersistableSpecTestException; end
+
+            expect(document.origin).to eq "London"
+            expect(document.likes).to eq 60
+            expect(document.member_count).to eq 10
           end
         end
 
-        it_behaves_like "an atomically updatable root document"
+        context "when given join_context: true" do
+
+          let(:run_update) do
+            document.atomically do |doc|
+              doc.inc(member_count: 10)
+              doc.my_updates join_context: true
+              doc.bit(likes: { and: 13 })
+            end
+          end
+
+          it_behaves_like "an atomically updatable root document" do
+            let!(:update) { run_update }
+          end
+
+          it "performs an update_one exactly once" do
+            expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).exactly(:once).and_call_original
+            run_update
+          end
+
+          it "resets in-memory changes that did not successfully persist" do
+            begin
+              document.atomically do |doc|
+                doc.set origin: "Paris"
+                doc.atomically(join_context: true) do |doc2|
+                  doc2.inc(member_count: 10)
+                end
+                doc.atomically(join_context: true) do |doc3|
+                  doc.inc likes: 1
+                end
+                raise PersistableSpecTestException, "oops"
+              end
+            rescue PersistableSpecTestException
+            end
+
+            expect(document.origin).to eq "London"
+            expect(document.likes).to eq 60
+            expect(document.member_count).to eq 0
+          end
+        end
       end
     end
 

data/spec/mongoid/persistence_context_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::PersistenceContext do

data/spec/mongoid/positional_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Positional do

data/spec/mongoid/query_cache_middleware_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::QueryCache::Middleware do
+
+  let :middleware do
+    Mongoid::QueryCache::Middleware.new(app)
+  end
+
+  context "when not touching mongoid on the app" do
+
+    let(:app) do
+      ->(env) { @enabled = Mongoid::QueryCache.enabled?; [200, env, "app"] }
+    end
+
+    it "returns success" do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    it "enableds the query cache" do
+      middleware.call({})
+      expect(@enabled).to be true
+    end
+  end
+
+  context "when querying on the app" do
+
+    let(:app) do
+      ->(env) {
+        Band.all.to_a
+        [200, env, "app"]
+      }
+    end
+
+    it "returns success" do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    context 'with driver query cache' do
+      min_driver_version '2.14'
+
+      it "cleans the query cache after it responds" do
+        middleware.call({})
+        expect(Mongo::QueryCache.send(:cache_table)).to be_empty
+      end
+    end
+
+    context 'with mongoid query cache' do
+      max_driver_version '2.13'
+
+      it "cleans the query cache after it responds" do
+        middleware.call({})
+        expect(Mongoid::QueryCache.cache_table).to be_empty
+      end
+    end
+  end
+
+  context 'when driver implements query cache middleware' do
+    min_driver_version '2.15'
+
+    it 'uses the driver query cache middleware' do
+      Mongoid::QueryCache::Middleware.should be Mongo::QueryCache::Middleware
+    end
+  end
+end