mongoid 8.0.9 → 8.1.0

data/spec/mongoid/query_cache_spec.rb

@@ -24,21 +24,12 @@ describe Mongoid::QueryCache do
     Mrss::SessionRegistry.instance.verify_sessions_ended!
   end
 
-  let(:reset_legacy_qc_warning) do
-    begin
-      Mongoid::QueryCache.remove_instance_variable('@legacy_query_cache_warned')
-    rescue NameError
-      # raised if the instance variable wasn't set
-    end
-  end
-
   describe '#cache' do
+
     context 'with driver query cache' do
 
       context 'when query cache is not enabled' do
-        before do
-          Mongoid::QueryCache.enabled = false
-        end
+        override_query_cache false
 
         it 'turns on the query cache within the block' do
           expect(Mongoid::QueryCache.enabled?).to be false
@@ -52,9 +43,7 @@ describe Mongoid::QueryCache do
       end
 
       context 'when query cache is enabled' do
-        before do
-          Mongoid::QueryCache.enabled = true
-        end
+        override_query_cache true
 
         it 'keeps the query cache enabled within the block' do
           expect(Mongoid::QueryCache.enabled?).to be true
@@ -84,12 +73,11 @@ describe Mongoid::QueryCache do
   end
 
   describe '#uncached' do
+
     context 'with driver query cache' do
 
       context 'when query cache is not enabled' do
-        before do
-          Mongoid::QueryCache.enabled = false
-        end
+        override_query_cache false
 
         it 'keeps the query cache turned off within the block' do
           expect(Mongoid::QueryCache.enabled?).to be false
@@ -103,9 +91,7 @@ describe Mongoid::QueryCache do
       end
 
       context 'when query cache is enabled' do
-        before do
-          Mongoid::QueryCache.enabled = true
-        end
+        override_query_cache true
 
         it 'turns off the query cache within the block' do
           expect(Mongoid::QueryCache.enabled?).to be true
@@ -159,10 +145,7 @@ describe Mongoid::QueryCache do
       end
 
       context 'does not query for the relation and instead sets the base' do
-
-        before do
-          Mongoid::QueryCache.enabled = false
-        end
+        override_query_cache false
 
         it 'queries for each access to the base' do
           expect(server).to receive(:with_connection).exactly(0).times.and_call_original
@@ -180,10 +163,7 @@ describe Mongoid::QueryCache do
       end
 
       context 'when query cache is disabled' do
-
-        before do
-          Mongoid::QueryCache.enabled = false
-        end
+        override_query_cache false
 
         it 'does not query for access to the base' do
           expect(server).to receive(:context).exactly(0).times.and_call_original
@@ -194,10 +174,7 @@ describe Mongoid::QueryCache do
       end
 
       context 'when query cache is enabled' do
-
-        before do
-          Mongoid::QueryCache.enabled = true
-        end
+        override_query_cache true
 
         it 'does not query for access to the base' do
           expect(server).to receive(:context).exactly(0).times.and_call_original
@@ -243,10 +220,7 @@ describe Mongoid::QueryCache do
     end
 
     context 'when block is cached' do
-
-      before do
-        Mongoid::QueryCache.enabled = false
-      end
+      override_query_cache false
 
       it 'uses the driver query cache' do
         expect(Mongo::QueryCache).to receive(:cache).and_call_original
@@ -259,10 +233,7 @@ describe Mongoid::QueryCache do
     end
 
     context 'when block is uncached' do
-
-      before do
-        Mongoid::QueryCache.enabled = true
-      end
+      override_query_cache true
 
       it 'uses the driver query cache' do
         expect(Mongo::QueryCache).to receive(:uncached).and_call_original
@@ -314,10 +285,7 @@ describe Mongoid::QueryCache do
       end
 
       context "when query cache is disabled" do
-
-        before do
-          Mongoid::QueryCache.enabled = false
-        end
+        override_query_cache false
 
         it "queries again" do
           expect_query(1) do
@@ -440,10 +408,7 @@ describe Mongoid::QueryCache do
     end
 
     context "when query cache is disabled" do
-
-      before do
-        Mongoid::QueryCache.enabled = false
-      end
+      override_query_cache false
 
       it "queries again" do
         expect_query(1) do
@@ -669,13 +634,7 @@ describe Mongoid::QueryCache do
    end
 
     context "when query caching is enabled and the batch_size is set" do
-
-      around(:each) do |example|
-        query_cache_enabled = Mongoid::QueryCache.enabled?
-        Mongoid::QueryCache.enabled = true
-        example.run
-        Mongoid::QueryCache.enabled = query_cache_enabled
-      end
+      override_query_cache true
 
       it "does not raise an error when requesting the second batch" do
         expect {
@@ -684,7 +643,6 @@ describe Mongoid::QueryCache do
           end
         }.not_to raise_error
       end
-
     end
   end
 
@@ -752,10 +710,7 @@ describe Mongoid::QueryCache do
     end
 
     context 'when query cache is disabled' do
-
-      before do
-        Mongoid::QueryCache.enabled = false
-      end
+      override_query_cache false
 
       it "queries again" do
         band = Band.find(band_id)
@@ -819,8 +774,9 @@ describe Mongoid::QueryCache do
   end
 
   context 'when the initial query does not exhaust the results' do
+    override_query_cache true
+
     before do
-      Mongoid::QueryCache.enabled = true
       10.times { Band.create! }
 
       Band.batch_size(4).to_a
@@ -867,4 +823,43 @@ describe Mongoid::QueryCache do
       school.students.to_a.length.should == 5
     end
   end
+
+  describe 'deprecation warnings' do
+
+    context '#cache' do
+      it 'should raise a warning' do
+        expect(Mongoid::Warnings).to receive(:warn_mongoid_query_cache)
+        Mongoid::QueryCache.cache {}
+      end
+    end
+
+    context '#uncached' do
+      it 'should raise a warning' do
+        expect(Mongoid::Warnings).to receive(:warn_mongoid_query_cache)
+        Mongoid::QueryCache.uncached {}
+      end
+    end
+
+    context '#clear_cache' do
+      it 'should raise a warning' do
+        expect(Mongoid::Warnings).to receive(:warn_mongoid_query_cache_clear)
+        Mongoid::QueryCache.clear_cache
+      end
+    end
+
+    context '#enabled?' do
+      it 'should raise a warning' do
+        expect(Mongoid::Warnings).to receive(:warn_mongoid_query_cache)
+        Mongoid::QueryCache.enabled?
+      end
+    end
+
+    context '#enabled=' do
+      it 'should raise a warning' do
+        old_enabled = Mongoid::QueryCache.enabled?
+        expect(Mongoid::Warnings).to receive(:warn_mongoid_query_cache)
+        Mongoid::QueryCache.enabled = old_enabled
+      end
+    end
+  end
 end

data/spec/mongoid/reloadable_spec.rb

@@ -390,30 +390,6 @@ describe Mongoid::Reloadable do
       end
     end
 
-    context 'when embeds_many is modified' do
-      let(:contractor1) { Contractor.new(name: 'b') }
-      let(:contractor2) { Contractor.new(name: 'c') }
-
-      let(:building) do
-        Building.create!(contractors: [ contractor1 ])
-      end
-
-      let(:more_contractors) { building.contractors + [ contractor2 ] }
-
-      let(:modified_building) do
-        building.tap do
-          building.assign_attributes contractors: more_contractors
-        end
-      end
-
-      let(:reloaded_building) { modified_building.reload }
-
-      it 'resets delayed_atomic_sets' do
-        expect(modified_building.delayed_atomic_sets).not_to be_empty
-        expect(reloaded_building.delayed_atomic_sets).to be_empty
-      end
-    end
-
     context "when embedded document is nil" do
 
       let(:palette) do
@@ -512,12 +488,32 @@ describe Mongoid::Reloadable do
         Person.create!
       end
 
-      let(:reloaded) do
-        Person.only(:name).first.reload
+      context "when legacy_readonly is on" do
+        config_override :legacy_readonly, true
+
+        let(:reloaded) do
+          Person.only(:name).first.reload
+        end
+
+        it 'resets the readonly state after reloading' do
+          expect(reloaded.readonly?).to be(false)
+        end
       end
 
-      it 'resets the readonly state after reloading' do
-        expect(reloaded.readonly?).to be(false)
+      context "when legacy_readonly is off" do
+        config_override :legacy_readonly, false
+
+        let(:reloaded) do
+          Person.only(:name).first.tap do |doc|
+            doc.readonly!
+            expect(doc.readonly?).to be true
+            doc.reload
+          end
+        end
+
+        it 'does not reset the readonly state after reloading' do
+          expect(reloaded.readonly?).to be(true)
+        end
       end
     end
 

data/spec/mongoid/scopable_spec.rb

@@ -121,6 +121,76 @@ describe Mongoid::Scopable do
         expect(selector).to eq({'active' => true})
       end
     end
+
+    context "when the default scope is dotted" do
+
+      let(:criteria) do
+        Band.where('tags.foo' => 'bar')
+      end
+
+      before do
+        Band.default_scope ->{ criteria }
+      end
+
+      after do
+        Band.default_scoping = nil
+      end
+
+      let!(:band) do
+        Band.create!
+      end
+
+      it "adds the scope as a dotted key attribute" do
+        expect(band.attributes['tags.foo']).to eq('bar')
+      end
+
+      it "adds the default scope to the class" do
+        expect(Band.default_scoping.call).to eq(criteria)
+      end
+
+      it "flags as being default scoped" do
+        expect(Band).to be_default_scoping
+      end
+
+      it "does not find the correct document" do
+        expect(Band.count).to eq(0)
+      end
+    end
+
+    context "when the default scope is dotted with a query" do
+
+      let(:criteria) do
+        Band.where('tags.foo' => {'$eq' => 'bar'})
+      end
+
+      before do
+        Band.default_scope ->{ criteria }
+      end
+
+      after do
+        Band.default_scoping = nil
+      end
+
+      let!(:band) do
+        Band.create!('tags' => { 'foo' => 'bar' })
+      end
+
+      it "does not add the scope as a dotted key attribute" do
+        expect(band.attributes).to_not have_key('tags.foo')
+      end
+
+      it "adds the default scope to the class" do
+        expect(Band.default_scoping.call).to eq(criteria)
+      end
+
+      it "flags as being default scoped" do
+        expect(Band).to be_default_scoping
+      end
+
+      it "finds the correct document" do
+        expect(Band.where.first).to eq(band)
+      end
+    end
   end
 
   describe ".default_scopable?" do

data/spec/mongoid/serializable_spec.rb

@@ -14,19 +14,19 @@ describe Mongoid::Serializable do
       expect(guitar.send(:field_names, {})).to eq(guitar.fields.except("_type").keys.sort)
     end
 
-    context "when using a custom discriminator_key" do 
-      before do 
+    context "when using a custom discriminator_key" do
+      before do
         Instrument.discriminator_key = "dkey"
       end
 
-      after do 
+      after do
         Instrument.discriminator_key = nil
       end
 
       let(:guitar) do
         Guitar.new
       end
-  
+
       it "includes _type but does not include the new discriminator key" do
         expect(guitar.send(:field_names, {})).to eq(guitar.fields.except("dkey").keys.sort)
       end
@@ -41,15 +41,11 @@ describe Mongoid::Serializable do
       end
 
       after do
-        Mongoid.include_root_in_json = false
         reload_model(:Minim)
       end
 
       context "when global config is set to true" do
-
-        before do
-          Mongoid.include_root_in_json = true
-        end
+        config_override :include_root_in_json, true
 
         it "returns true" do
           expect(Minim.public_send(meth)).to be true
@@ -67,10 +63,7 @@ describe Mongoid::Serializable do
       end
 
       context "when global config set to false" do
-
-        before do
-          Mongoid.include_root_in_json = false
-        end
+        config_override :include_root_in_json, false
 
         it "returns false" do
           expect(Minim.public_send(meth)).to be false
@@ -89,13 +82,13 @@ describe Mongoid::Serializable do
     end
 
     describe "#include_root_in_json" do
+      config_override :include_root_in_json, false
 
       before do
         reload_model(:Minim)
       end
 
       after do
-        Mongoid.include_root_in_json = false
         reload_model(:Minim)
       end
 
@@ -127,10 +120,6 @@ describe Mongoid::Serializable do
 
       context "when global config set to false" do
 
-        before do
-          Mongoid.include_root_in_json = false
-        end
-
         it "returns false" do
           expect(minim.public_send(meth)).to be false
         end
@@ -297,14 +286,7 @@ describe Mongoid::Serializable do
       end
 
       context "when include_type_for_serialization is true" do
-
-        before do
-          Mongoid.include_type_for_serialization = true
-        end
-
-        after do
-          Mongoid.include_type_for_serialization = false
-        end
+        config_override :include_type_for_serialization, true
 
         it "includes _type field" do
           expect(person.serializable_hash.keys).to include '_type'
@@ -528,13 +510,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
 
@@ -545,13 +527,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
 
@@ -670,8 +652,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
 
@@ -682,8 +664,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
 
@@ -694,8 +676,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
@@ -881,16 +863,13 @@ describe Mongoid::Serializable do
     end
 
     context "when including root in json via Mongoid" do
+      config_override :include_root_in_json, false
 
       before do
         account.include_root_in_json.should be false
         Mongoid.include_root_in_json = true
       end
 
-      after do
-        Mongoid.include_root_in_json = false
-      end
-
       it "uses the mongoid configuration" do
         expect(JSON.parse(account.to_json)).to have_key("account")
       end

data/spec/mongoid/stateful_spec.rb

@@ -136,21 +136,135 @@ describe Mongoid::Stateful do
       Band.new
     end
 
-    context "when the document is readonly" do
+    context "when legacy_readonly is true" do
+      config_override :legacy_readonly, true
 
-      before do
-        document.__selected_fields = { test: 1 }
+      context "when the selected fields are set" do
+
+        before do
+          document.__selected_fields = { test: 1 }
+        end
+
+        it "returns true" do
+          expect(document).to be_readonly
+        end
       end
 
-      it "returns true" do
-        expect(document).to be_readonly
+      context "when no readonly has been set" do
+
+        it "returns false" do
+          expect(document).to_not be_readonly
+        end
+      end
+
+      context "when the readonly! method is called" do
+
+        let(:op) do
+          document.readonly!
+        end
+
+        it "returns false" do
+          op
+          expect(document).to_not be_readonly
+        end
+
+        it "warns" do
+          expect(Mongoid::Warnings).to receive(:warn_legacy_readonly)
+          op
+        end
+      end
+
+      context "when overriding readonly?" do
+
+        let(:doc) { ReadonlyModel.create! }
+
+        before do
+          class ReadonlyModel
+            include Mongoid::Document
+
+            attr_accessor :locked
+
+            def readonly?
+              !!locked
+            end
+          end
+        end
+
+        after do
+          Object.send(:remove_const, :ReadonlyModel)
+        end
+
+        it "raises when readonly? is true" do
+          expect(doc.readonly?).to be false
+          doc.locked = true
+          expect(doc.readonly?).to be true
+          expect do
+            doc.destroy
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
       end
     end
 
-    context "when no readonly has been set" do
+    context "when legacy_readonly is false" do
+      config_override :legacy_readonly, false
 
-      it "returns false" do
-        expect(document).to_not be_readonly
+      context "when the selected fields are set" do
+
+        before do
+          document.__selected_fields = { test: 1 }
+        end
+
+        it "returns false" do
+          expect(document).to_not be_readonly
+        end
+      end
+
+      context "when the readonly! method is called" do
+
+        before do
+          document.readonly!
+        end
+
+        it "returns true" do
+          expect(document).to be_readonly
+        end
+      end
+
+      context "when no readonly has been set" do
+
+        it "returns false" do
+          expect(document).to_not be_readonly
+        end
+      end
+
+      context "when overriding readonly?" do
+
+        let(:doc) { ReadonlyModel.new }
+
+        before do
+          class ReadonlyModel
+            include Mongoid::Document
+
+            attr_accessor :locked
+
+            def readonly?
+              !!locked
+            end
+          end
+        end
+
+        after do
+          Object.send(:remove_const, :ReadonlyModel)
+        end
+
+        it "raises when readonly? is true" do
+          expect(doc.readonly?).to be false
+          doc.locked = true
+          expect(doc.readonly?).to be true
+          expect do
+            doc.save!
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
       end
     end
   end