mongoid 7.5.1 → 8.1.4

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'
@@ -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/shardable_models.rb

@@ -59,3 +59,17 @@ 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

data/spec/mongoid/shardable_spec.rb

@@ -27,11 +27,11 @@ describe Mongoid::Shardable do
     context 'when full syntax is used' do
       context 'with symbol value' do
         it 'sets shard key fields to symbol value' do
-          SmProducer.shard_key_fields.should == %i(age gender)
+          expect(SmProducer.shard_key_fields).to be == %i(age gender)
         end
 
         it 'sets shard config' do
-          SmProducer.shard_config.should == {
+          expect(SmProducer.shard_config).to be == {
             key: {age: 1, gender: 'hashed'},
             options: {
               unique: true,
@@ -41,37 +41,37 @@ describe Mongoid::Shardable do
         end
 
         it 'keeps hashed as string' do
-          SmProducer.shard_config[:key][:gender].should == 'hashed'
+          expect(SmProducer.shard_config[:key][:gender]).to be == 'hashed'
         end
       end
 
       context 'with string value' do
         it 'sets shard key fields to symbol value' do
-          SmActor.shard_key_fields.should == %i(age gender hello)
+          expect(SmActor.shard_key_fields).to be == %i(age gender hello)
         end
 
         it 'sets shard config' do
-          SmActor.shard_config.should == {
+          expect(SmActor.shard_config).to be == {
             key: {age: 1, gender: 'hashed', hello: 'hashed'},
             options: {},
           }
         end
 
         it 'sets hashed to string' do
-          SmActor.shard_config[:key][:gender].should == 'hashed'
+          expect(SmActor.shard_config[:key][:gender]).to be == 'hashed'
         end
       end
 
       context 'when passed association name' do
         it 'uses foreign key as shard key in shard config' do
-          SmDriver.shard_config.should == {
+          expect(SmDriver.shard_config).to be == {
             key: {age: 1, agency_id: 'hashed'},
             options: {},
           }
         end
 
         it 'uses foreign key as shard key in shard key fields' do
-          SmDriver.shard_key_fields.should == %i(age agency_id)
+          expect(SmDriver.shard_key_fields).to be == %i(age agency_id)
         end
       end
     end
@@ -79,26 +79,26 @@ describe Mongoid::Shardable do
     context 'when shorthand syntax is used' do
       context 'with symbol value' do
         it 'sets shard key fields to symbol value' do
-          SmMovie.shard_key_fields.should == %i(year)
+          expect(SmMovie.shard_key_fields).to be == %i(year)
         end
       end
 
       context 'with string value' do
         it 'sets shard key fields to symbol value' do
-          SmTrailer.shard_key_fields.should == %i(year)
+          expect(SmTrailer.shard_key_fields).to be == %i(year)
         end
       end
 
       context 'when passed association name' do
         it 'uses foreign key as shard key in shard config' do
-          SmDirector.shard_config.should == {
+          expect(SmDirector.shard_config).to be == {
             key: {agency_id: 1},
             options: {},
           }
         end
 
         it 'uses foreign key as shard key in shard key fields' do
-          SmDirector.shard_key_fields.should == %i(agency_id)
+          expect(SmDirector.shard_key_fields).to be == %i(agency_id)
         end
       end
     end
@@ -106,41 +106,80 @@ describe Mongoid::Shardable do
 
   describe '#shard_key_selector' do
     subject { instance.shard_key_selector }
-    let(:klass) { Band }
-    let(:value) { 'a-brand-name' }
+    
+    context 'when key is an immediate attribute' do
+      let(:klass) { Band }
+      let(:value) { 'a-brand-name' }
 
-    before { klass.shard_key(:name) }
+      before { klass.shard_key(:name) }
 
-    context 'when record is new' do
-      let(:instance) { klass.new(name: value) }
+      context 'when record is new' do
+        let(:instance) { klass.new(name: value) }
 
-      it { is_expected.to eq({ 'name' => value }) }
+        it { is_expected.to eq({ 'name' => value }) }
 
-      context 'changing shard key value' do
-        let(:new_value) { 'a-new-value' }
+        context 'changing shard key value' do
+          let(:new_value) { 'a-new-value' }
 
-        before do
-          instance.name = new_value
+          before do
+            instance.name = new_value
+          end
+
+          it { is_expected.to eq({ 'name' => new_value }) }
         end
+      end
+
+      context 'when record is persisted' do
+        let(:instance) { klass.create!(name: value) }
+
+        it { is_expected.to eq({ 'name' => value }) }
+
+        context 'changing shard key value' do
+          let(:new_value) { 'a-new-value' }
+
+          before do
+            instance.name = new_value
+          end
 
-        it { is_expected.to eq({ 'name' => new_value }) }
+          it { is_expected.to eq({ 'name' => new_value }) }
+        end
       end
     end
 
-    context 'when record is persisted' do
-      let(:instance) { klass.create!(name: value) }
+    context 'when key is an embedded attribute' do
+      let(:klass) { SmReview }
+      let(:value) { 'Arthur Conan Doyle' }
+      let(:key)   { 'author.name' }
 
-      it { is_expected.to eq({ 'name' => value }) }
+      context 'when record is new' do
+        let(:instance) { klass.new(author: { name: value }) }
 
-      context 'changing shard key value' do
-        let(:new_value) { 'a-new-value' }
+        it { is_expected.to eq({ key => value }) }
 
-        before do
-          instance.name = new_value
+        context 'changing shard key value' do
+          let(:new_value) { 'Jules Verne' }
+
+          before do
+            instance.author.name = new_value
+          end
+
+          it { is_expected.to eq({ key => new_value }) }
         end
+      end
+
+      context 'when record is persisted' do
+        let(:instance) { klass.create!(author: { name: value }) }
+
+        it { is_expected.to eq({ key => value }) }
+
+        context 'changing shard key value' do
+          let(:new_value) { 'Jules Verne' }
+
+          before do
+            instance.author.name = new_value
+          end
 
-        it 'uses the newly set shard key value' do
-          subject.should == { 'name' => new_value }
+          it { is_expected.to eq({ 'author.name' => new_value }) }
         end
       end
     end
@@ -148,42 +187,109 @@ describe Mongoid::Shardable do
 
   describe '#shard_key_selector_in_db' do
     subject { instance.shard_key_selector_in_db }
-    let(:klass) { Band }
-    let(:value) { 'a-brand-name' }
 
-    before { klass.shard_key(:name) }
+    context 'when key is an immediate attribute' do
+      let(:klass) { Band }
+      let(:value) { 'a-brand-name' }
 
-    context 'when record is new' do
-      let(:instance) { klass.new(name: value) }
+      before { klass.shard_key(:name) }
 
-      it { is_expected.to eq({ 'name' => value }) }
+      context 'when record is new' do
+        let(:instance) { klass.new(name: value) }
 
-      context 'changing shard key value' do
-        let(:new_value) { 'a-new-value' }
+        it { is_expected.to eq({ 'name' => value }) }
+
+        context 'changing shard key value' do
+          let(:new_value) { 'a-new-value' }
+
+          before do
+            instance.name = new_value
+          end
+
+          it { is_expected.to eq({ 'name' => new_value }) }
+        end
+      end
+
+      context 'when record is persisted' do
+        let(:instance) { klass.create!(name: value) }
+
+        it { is_expected.to eq({ 'name' => value }) }
+
+        context 'changing shard key value' do
+          let(:new_value) { 'a-new-value' }
+
+          before do
+            instance.name = new_value
+          end
+
+          it { is_expected.to eq({ 'name' => value }) }
+        end
+      end
+
+      context "when record is not found" do
+        let!(:instance) { klass.create!(name: value) }
 
         before do
-          instance.name = new_value
+          instance.destroy
         end
 
-        it 'uses the existing shard key value' do
-          subject.should == { 'name' => new_value }
+        it "raises a DocumentNotFound error with the shard key in the description on reload" do
+          expect do
+            instance.reload
+          end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Band with id #{instance.id.to_s} and shard key name: a-brand-name./)
         end
       end
     end
 
-    context 'when record is persisted' do
-      let(:instance) { klass.create!(name: value) }
+    context 'when key is an embedded attribute' do
+      let(:klass) { SmReview }
+      let(:value) { 'Arthur Conan Doyle' }
+      let(:key)   { 'author.name' }
 
-      it { is_expected.to eq({ 'name' => value }) }
+      context 'when record is new' do
+        let(:instance) { klass.new(author: { name: value }) }
 
-      context 'changing shard key value' do
-        let(:new_value) { 'a-new-value' }
+        it { is_expected.to eq({ key => value }) }
 
-        before do
-          instance.name = new_value
+        context 'changing shard key value' do
+          let(:new_value) { 'Jules Verne' }
+
+          before do
+            instance.author.name = new_value
+          end
+
+          it { is_expected.to eq({ key => new_value }) }
         end
+      end
 
-        it { is_expected.to eq({ 'name' => value }) }
+      context 'when record is persisted' do
+        let(:instance) { klass.create!(author: { name: value }) }
+
+        it { is_expected.to eq({ key => value }) }
+
+        context 'changing shard key value' do
+          let(:new_value) { 'Jules Verne' }
+
+          before do
+            instance.author.name = new_value
+          end
+
+          it { is_expected.to eq({ key => value }) }
+        end
+
+        context "when record is not found" do
+          let!(:instance) { klass.create!(author: { name: value }) }
+  
+          before do
+            instance.destroy
+          end
+  
+          it "raises a DocumentNotFound error with the shard key in the description on reload" do
+            expect do
+              instance.reload
+            end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class SmReview with id #{instance.id.to_s} and shard key author.name: Arthur Conan Doyle./)
+          end
+        end
       end
     end
   end

data/spec/mongoid/stateful_spec.rb

@@ -40,6 +40,25 @@ describe Mongoid::Stateful do
     end
   end
 
+  describe '#previously_new_record?' do
+    it "returns correct values" do
+      person = Person.new
+      expect(person).not_to be_a_previously_new_record
+      person.save!
+      expect(person).to be_a_previously_new_record
+      person.title = "Title"
+      person.save!
+      expect(person).not_to be_a_previously_new_record
+    end
+
+    it "resets after reload" do
+      person = Person.create!
+      expect(person).to be_a_previously_new_record
+      person.reload
+      expect(person).not_to be_a_previously_new_record
+    end
+  end
+
   describe "#persisted?" do
 
     let(:person) do
@@ -62,6 +81,15 @@ describe Mongoid::Stateful do
     end
   end
 
+  describe "#previously_persisted?" do
+    it "returns true after being destroyed" do
+      person = Person.create!
+      expect(person).not_to be_previously_persisted
+      person.destroy
+      expect(person).to be_previously_persisted
+    end
+  end
+
   describe "destroyed?" do
 
     let(:person) do
@@ -108,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