mongoid 7.6.0 → 8.0.1

data/spec/mongoid/query_cache_spec.rb

@@ -4,7 +4,6 @@ require "spec_helper"
 require 'mongoid/association/referenced/has_many_models'
 
 describe Mongoid::QueryCache do
-  require_mri
 
   around do |spec|
     Mongoid::QueryCache.clear_cache
@@ -22,7 +21,7 @@ describe Mongoid::QueryCache do
   end
 
   after do
-    # Mrss::SessionRegistry.instance.verify_sessions_ended!
+    Mrss::SessionRegistry.instance.verify_sessions_ended!
   end
 
   let(:reset_legacy_qc_warning) do
@@ -35,66 +34,6 @@ describe Mongoid::QueryCache do
 
   describe '#cache' do
     context 'with driver query cache' do
-      min_driver_version '2.14'
-
-      it 'does not log a deprecation warning' do
-        reset_legacy_qc_warning
-
-        expect_any_instance_of(Logger).to_not receive(:warn).with(
-          described_class::LEGACY_WARNING
-        )
-        described_class.cache { }
-      end
-
-      context 'when query cache is not enabled' do
-        before do
-          Mongoid::QueryCache.enabled = false
-        end
-
-        it 'turns on the query cache within the block' do
-          expect(Mongoid::QueryCache.enabled?).to be false
-
-          Mongoid::QueryCache.cache do
-            expect(Mongoid::QueryCache.enabled?).to be true
-          end
-
-          expect(Mongoid::QueryCache.enabled?).to be false
-        end
-      end
-
-      context 'when query cache is enabled' do
-        before do
-          Mongoid::QueryCache.enabled = true
-        end
-
-        it 'keeps the query cache enabled within the block' do
-          expect(Mongoid::QueryCache.enabled?).to be true
-
-          Mongoid::QueryCache.cache do
-            expect(Mongoid::QueryCache.enabled?).to be true
-          end
-
-          expect(Mongoid::QueryCache.enabled?).to be true
-        end
-      end
-
-      context 'nested inside #uncached' do
-        it 'turns on the query cache in the block' do
-          Mongoid::QueryCache.uncached do
-            expect(Mongoid::QueryCache.enabled?).to be false
-
-            Mongoid::QueryCache.cache do
-              expect(Mongoid::QueryCache.enabled?).to be true
-            end
-
-            expect(Mongoid::QueryCache.enabled?).to be false
-          end
-        end
-      end
-    end
-
-    context 'with mongoid query cache' do
-      max_driver_version '2.13'
 
       context 'when query cache is not enabled' do
         before do
@@ -146,64 +85,6 @@ describe Mongoid::QueryCache do
 
   describe '#uncached' do
     context 'with driver query cache' do
-      min_driver_version '2.14'
-
-      context 'when query cache is not enabled' do
-        before do
-          Mongoid::QueryCache.enabled = false
-        end
-
-        it 'keeps the query cache turned off within the block' do
-          expect(Mongoid::QueryCache.enabled?).to be false
-
-          Mongoid::QueryCache.uncached do
-            expect(Mongoid::QueryCache.enabled?).to be false
-          end
-
-          expect(Mongoid::QueryCache.enabled?).to be false
-        end
-      end
-
-      context 'when query cache is enabled' do
-        before do
-          Mongoid::QueryCache.enabled = true
-        end
-
-        it 'turns off the query cache within the block' do
-          expect(Mongoid::QueryCache.enabled?).to be true
-
-          Mongoid::QueryCache.uncached do
-            expect(Mongoid::QueryCache.enabled?).to be false
-          end
-
-          expect(Mongoid::QueryCache.enabled?).to be true
-        end
-      end
-
-      context 'nested inside #cache' do
-        it 'turns on the query cache in the block' do
-          Mongoid::QueryCache.cache do
-            expect(Mongoid::QueryCache.enabled?).to be true
-
-            Mongoid::QueryCache.uncached do
-              expect(Mongoid::QueryCache.enabled?).to be false
-            end
-
-            expect(Mongoid::QueryCache.enabled?).to be true
-          end
-        end
-      end
-    end
-
-    context 'with mongoid query cache' do
-      max_driver_version '2.13'
-
-      it 'logs a deprecation warning' do
-        reset_legacy_qc_warning
-
-        expect_any_instance_of(Logger).to receive(:warn).with(described_class::LEGACY_WARNING)
-        described_class.cache { }
-      end
 
       context 'when query cache is not enabled' do
         before do
@@ -329,7 +210,6 @@ describe Mongoid::QueryCache do
   end
 
   context 'when driver query cache exists' do
-    min_driver_version '2.14'
 
     before do
       Band.all.to_a
@@ -425,14 +305,6 @@ describe Mongoid::QueryCache do
     end
   end
 
-  context 'when drivers query cache does not exist' do
-    max_driver_version '2.13'
-
-    it 'does not recognize the driver query cache' do
-      expect(defined?(Mongo::QueryCache)).to be_nil
-    end
-  end
-
   context "when querying for a single document" do
 
     [ :first, :one, :last ].each do |method|
@@ -663,12 +535,8 @@ describe Mongoid::QueryCache do
         end
 
         context "when the next query has a limit" do
-          # Server versions older than 3.2 also perform a killCursors operation,
-          # which causes this test to fail.
-          min_server_version '3.2'
 
           context 'with driver query cache' do
-            min_driver_version '2.14'
 
             # The driver query cache re-uses results with a larger limit
             it 'does not query again' do
@@ -679,18 +547,6 @@ describe Mongoid::QueryCache do
               end
             end
           end
-
-          context 'with mongoid query cache' do
-            max_driver_version '2.13'
-
-            it 'queries again' do
-              expect_query(1) do
-                result = game.ratings.where(:value.gt => 5).limit(2).asc(:id).to_a
-                expect(result.length).to eq(2)
-                expect(result.map { |r| r['value'] }).to eq([6, 7])
-              end
-            end
-          end
         end
 
         context "when the new query does not have a limit" do
@@ -971,7 +827,6 @@ describe Mongoid::QueryCache do
     end
 
     context 'with driver query cache' do
-      min_driver_version '2.14'
 
       # The driver query cache caches multi-batch cursors
       it 'does cache the result' do
@@ -980,16 +835,6 @@ describe Mongoid::QueryCache do
         end
       end
     end
-
-    context 'with mongoid query cache' do
-      max_driver_version '2.13'
-
-      it 'does not cache the result' do
-        expect_query(1) do
-          expect(Band.all.map(&:id).size).to eq(10)
-        end
-      end
-    end
   end
 
   context 'when storing in system collection' do

data/spec/mongoid/reloadable_spec.rb

@@ -103,7 +103,7 @@ describe Mongoid::Reloadable do
       end
 
       it "resets attributes_before_type_cast" do
-        expect(person.attributes_before_type_cast).to be_empty
+        expect(person.attributes_before_type_cast).to eq(person.attributes)
       end
     end
 
@@ -114,7 +114,7 @@ describe Mongoid::Reloadable do
         it "raises an error" do
           expect {
             Person.new.reload
-          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
         end
       end
 
@@ -628,5 +628,38 @@ describe Mongoid::Reloadable do
         church.acolytes.first.name.should == 'Borg'
       end
     end
+
+    context 'when document has previous changes' do
+      context 'when document was updated' do
+        let(:person) do
+          Person.create!(title: 'Sir')
+        end
+
+        before do
+          person.title = 'Madam'
+          person.save!
+          person.reload
+        end
+
+        it "resets previous changes" do
+          expect(person.title_previously_was).to be_nil
+          expect(person).not_to be_previously_persisted
+        end
+      end
+
+      context 'when document was created' do
+        let(:person) do
+          Person.create!(title: 'Sir')
+        end
+
+        before do
+          person.reload
+        end
+
+        it "resets previous changes" do
+          expect(person).not_to be_previously_new_record
+        end
+      end
+    end
   end
 end

data/spec/mongoid/scopable_spec.rb

@@ -481,45 +481,27 @@ describe Mongoid::Scopable do
 
       context "when a block is provided" do
 
-        context "when with optional and keyword arguments" do
-          before do
-            Band.scope(:named_by, ->(name, deleted: false) {
-              Band.where(name: name, deleted: deleted)
-            })
-          end
-
-          let(:scope) do
-            Band.named_by("Emily", deleted: true)
-          end
-
-          it "sets the conditions from keyword arguments" do
-            scope.selector.should == {'name' => 'Emily', 'deleted' => true}
-          end
-        end
-
-        context "when without arguments" do
-          before do
-            Band.scope(:active, ->{ Band.where(active: true) }) do
-              def add_origin
-                tap { |c| c.selector[:origin] = "Deutschland" }
-              end
+        before do
+          Band.scope(:active, ->{ Band.where(active: true) }) do
+            def add_origin
+              tap { |c| c.selector[:origin] = "Deutschland" }
             end
           end
+        end
 
-          after do
-            class << Band
-              undef_method :active
-            end
-            Band._declared_scopes.clear
+        after do
+          class << Band
+            undef_method :active
           end
+          Band._declared_scopes.clear
+        end
 
-          let(:scope) do
-            Band.active.add_origin
-          end
+        let(:scope) do
+          Band.active.add_origin
+        end
 
-          it "adds the extension to the scope" do
-            expect(scope.selector).to eq({ "active" => true, "origin" => "Deutschland" })
-          end
+        it "adds the extension to the scope" do
+          expect(scope.selector).to eq({ "active" => true, "origin" => "Deutschland" })
         end
       end
 
@@ -801,9 +783,11 @@ describe Mongoid::Scopable do
             "$or" => [
               { "ccc" => nil },
               { "ccc" => { "$gt" => 1.0 }},
+            ],
+            '$and' => ['$or' => [
               { "aaa" => { "$gt" => 0.0 }},
               { "bbb" => { "$gt" => 0.0 }}
-            ]
+            ]],
           })
         end
       end
@@ -1188,6 +1172,24 @@ describe Mongoid::Scopable do
         end
       end
     end
+
+    context 'when nesting unsoped under with_scope' do
+      let(:c1) { Band.where(active: true) }
+
+      it 'restores previous scope' do
+        pending 'MONGOID-5214'
+
+        Band.with_scope(c1) do |crit|
+          Band.unscoped do |crit2|
+            Mongoid::Threaded.current_scope(Band).should be nil
+          end
+
+          Mongoid::Threaded.current_scope(Band).selector.should == {
+            'active' => true,
+          }
+        end
+      end
+    end
   end
 
   describe ".without_default_scope" do

data/spec/mongoid/serializable_spec.rb

@@ -528,11 +528,13 @@ describe Mongoid::Serializable do
             end
 
             it "includes the first relation" do
-              expect(relation_hash[0]).to include({ "_id" => "kudamm", "street" => "Kudamm" })
+              expect(relation_hash[0]).to include
+                { "_id" => "kudamm", "street" => "Kudamm" }
             end
 
             it "includes the second relation" do
-              expect(relation_hash[1]).to include( "_id" => "tauentzienstr", "street" => "Tauentzienstr" )
+              expect(relation_hash[1]).to include
+                { "_id" => "tauentzienstr", "street" => "Tauentzienstr" }
             end
           end
 
@@ -543,11 +545,13 @@ describe Mongoid::Serializable do
             end
 
             it "includes the first relation" do
-              expect(relation_hash[0]).to include({ "_id" => "kudamm", "street" => "Kudamm" })
+              expect(relation_hash[0]).to include
+                { "_id" => "kudamm", "street" => "Kudamm" }
             end
 
             it "includes the second relation" do
-              expect(relation_hash[1]).to include({ "_id" => "tauentzienstr", "street" => "Tauentzienstr" })
+              expect(relation_hash[1]).to include
+                { "_id" => "tauentzienstr", "street" => "Tauentzienstr" }
             end
           end
 
@@ -666,7 +670,8 @@ describe Mongoid::Serializable do
             end
 
             it "includes the specified relation" do
-              expect(relation_hash).to include({ "_id" => "Leo-Marvin", "first_name" => "Leo", "last_name" => "Marvin" })
+              expect(relation_hash).to include
+                { "_id" => "leo-marvin", "first_name" => "Leo", "last_name" => "Marvin" }
             end
           end
 
@@ -677,7 +682,8 @@ describe Mongoid::Serializable do
             end
 
             it "includes the specified relation" do
-              expect(relation_hash).to include({ "_id" => "Leo-Marvin", "first_name" => "Leo", "last_name" => "Marvin" })
+              expect(relation_hash).to include
+                { "_id" => "leo-marvin", "first_name" => "Leo", "last_name" => "Marvin" }
             end
           end
 
@@ -688,7 +694,8 @@ describe Mongoid::Serializable do
             end
 
             it "includes the specified relation sans exceptions" do
-              expect(relation_hash).to include({ "first_name" => "Leo", "last_name" => "Marvin" })
+              expect(relation_hash).to include
+                { "first_name" => "Leo", "last_name" => "Marvin" }
             end
           end
         end

data/spec/mongoid/shardable_models.rb

@@ -59,17 +59,3 @@ end
 class SmNotSharded
   include Mongoid::Document
 end
-
-class SmReviewAuthor
-  include Mongoid::Document
-  embedded_in :review, class_name: "SmReview", touch: false
-  field :name, type: String
-end
-
-class SmReview
-  include Mongoid::Document
-
-  embeds_one :author, class_name: "SmReviewAuthor"
-
-  shard_key "author.name" => 1
-end