mongoid 7.6.0 → 8.0.1

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