mongoid 8.0.13 → 8.1.0

data/spec/mongoid/attributes/nested_spec.rb

@@ -7,33 +7,6 @@ require_relative './nested_spec_models'
 
 describe Mongoid::Attributes::Nested do
 
-  # Expects the enclosing context to define `build_with_id`, taking an id
-  # value and returning the document built with it in nested attributes.
-  shared_examples 'rejects non-scalar ids' do |klass_name|
-    not_found = /not found for class #{klass_name}/
-
-    context 'when the id is an operator hash' do
-      it 'raises a document not found error' do
-        expect { build_with_id({ '$ne' => nil }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
-      end
-    end
-
-    context 'when the id is an array' do
-      it 'raises a document not found error' do
-        expect { build_with_id([BSON::ObjectId.new]) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
-      end
-    end
-
-    context 'when the id is a malformed object id hash' do
-      it 'raises a document not found error' do
-        expect { build_with_id({ '$oid' => 'junk' }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
-      end
-    end
-  end
-
   describe ".accepts_nested_attributes_for" do
 
     context "when the autosave option is not defined" do
@@ -205,30 +178,6 @@ describe Mongoid::Attributes::Nested do
       end
     end
 
-    context 'when the id in the attributes is not a scalar' do
-      let(:person) { Person.create! }
-
-      def build_with_id(id)
-        person.update!(posts_attributes: { '0' => { id: id, title: 'Crafted' } })
-      end
-
-      context 'when the association is empty' do
-        include_examples 'rejects non-scalar ids', 'Post'
-      end
-
-      context 'when the association is not empty' do
-        before { person.posts.create!(title: 'Existing') }
-
-        include_examples 'rejects non-scalar ids', 'Post'
-      end
-
-      context 'when allow_reparenting_via_nested_attributes is true' do
-        config_override :allow_reparenting_via_nested_attributes, true
-
-        include_examples 'rejects non-scalar ids', 'Post'
-      end
-    end
-
     context "when the relation is a references and referenced in many" do
 
       before do
@@ -252,100 +201,16 @@ describe Mongoid::Attributes::Nested do
           )
         end
 
-        context 'when allow_reparenting_via_nested_attributes is false' do
-          config_override :allow_reparenting_via_nested_attributes, false
-
-          it 'raises a document not found error' do
-            expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
-                                             /Document\(s\) not found for class Preference/)
-          end
-        end
-
-        context 'when allow_reparenting_via_nested_attributes is true' do
-          config_override :allow_reparenting_via_nested_attributes, true
-
-          it 'sets the nested attributes' do
-            expect(person.preferences.map(&:name)).to eq([preference.name])
-          end
-
-          it 'updates attributes of existing document which is added to relation' do
-            preference_name = 'updated preference'
-            person = Person.new(
-              preferences_attributes: { 0 => { id: preference.id, name: preference_name } }
-            )
-            expect(person.preferences.map(&:name)).to eq([preference_name])
-          end
-
-          context 'when the id does not correspond to an existing document' do
-            let(:person) do
-              Person.new(
-                preferences_attributes: { 0 => { id: BSON::ObjectId.new, name: 'Ghost' } }
-              )
-            end
-
-            context 'when raise_not_found_error is true' do
-              config_override :raise_not_found_error, true
-
-              it 'raises a document not found error' do
-                expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
-                                                 /Document\(s\) not found for class Preference/)
-              end
-            end
-
-            context 'when raise_not_found_error is false' do
-              config_override :raise_not_found_error, false
-
-              it 'raises a document not found error' do
-                expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
-                                                 /Document\(s\) not found for class Preference/)
-              end
-            end
-          end
-        end
-
-        context 'when _destroy is true for a document not in the relation' do
-          before do
-            Person.send(:undef_method, :preferences_attributes=)
-            Person.accepts_nested_attributes_for :preferences, allow_destroy: true
-          end
-
-          let(:person) do
-            Person.new(
-              preferences_attributes: { 0 => { id: preference.id, _destroy: '1' } }
-            )
-          end
-
-          it 'does not raise UnknownAttribute' do
-            expect { person }.not_to raise_error
-          end
-
-          it 'does not add the document to the relation' do
-            expect(person.preferences).to be_empty
-          end
-        end
-      end
-
-      context 'when the id in the attributes is not a scalar' do
-        let(:target) { Person.create! }
-
-        def build_with_id(id)
-          target.update!(preferences_attributes: { 0 => { id: id, name: 'Crafted' } })
-        end
-
-        context 'when the association is empty' do
-          include_examples 'rejects non-scalar ids', 'Preference'
-        end
-
-        context 'when the association is not empty' do
-          before { target.preferences.create!(name: 'Existing') }
-
-          include_examples 'rejects non-scalar ids', 'Preference'
+        it "sets the nested attributes" do
+          expect(person.preferences.map(&:name)).to eq([preference.name])
         end
 
-        context 'when allow_reparenting_via_nested_attributes is true' do
-          config_override :allow_reparenting_via_nested_attributes, true
-
-          include_examples 'rejects non-scalar ids', 'Preference'
+        it "updates attributes of existing document which is added to relation" do
+          preference_name = 'updated preference'
+          person = Person.new(
+            preferences_attributes: { 0 => { id: preference.id, name: preference_name } }
+          )
+          expect(person.preferences.map(&:name)).to eq([preference_name])
         end
       end
     end
@@ -3150,7 +3015,7 @@ describe Mongoid::Attributes::Nested do
                       { "0" =>
                         { "id" => BSON::ObjectId.new.to_s, "title" => "Rogue" }
                       }
-                  }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Post/)
+                  }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
                 end
               end
             end
@@ -3184,7 +3049,7 @@ describe Mongoid::Attributes::Nested do
                 expect {
                   person.posts_attributes =
                     { "foo" => { "id" => "test", "title" => "Test" } }
-                }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Post/)
+                }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
               end
             end
           end
@@ -5132,63 +4997,4 @@ describe Mongoid::Attributes::Nested do
       end
     end
   end
-
-  context 'when an id in nested attributes belongs to another parent' do
-    let(:victim) { Person.create! }
-    let(:attacker) { Person.create! }
-
-    context 'when the association is a has-many' do
-      before do
-        Person.send(:undef_method, :posts_attributes=)
-        Person.accepts_nested_attributes_for :posts
-      end
-
-      let!(:victim_post) { victim.posts.create!(title: 'Private') }
-
-      it 'does not update the other parent\'s document' do
-        expect { attacker.update!(posts_attributes: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound)
-        expect(victim_post.reload.title).to eq('Private')
-      end
-
-      it 'does not add the other parent\'s document to the association' do
-        expect { attacker.update!(posts_attributes: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound)
-        expect(attacker.reload.posts).to be_empty
-      end
-
-      it 'does not update via a direct association assignment' do
-        expect { attacker.update!(posts: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound)
-        expect(victim_post.reload.title).to eq('Private')
-      end
-    end
-
-    context 'when the association is a has-and-belongs-to-many' do
-      before do
-        Person.send(:undef_method, :preferences_attributes=)
-        Person.accepts_nested_attributes_for :preferences
-      end
-
-      let!(:victim_preference) { victim.preferences.create!(name: 'Private') }
-
-      it 'does not update the other parent\'s document' do
-        expect { attacker.update!(preferences_attributes: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound)
-        expect(victim_preference.reload.name).to eq('Private')
-      end
-
-      it 'does not add the other parent\'s document to the association' do
-        expect { attacker.update!(preferences_attributes: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound)
-        expect(attacker.reload.preferences).to be_empty
-      end
-
-      it 'does not update via a direct association assignment' do
-        expect { attacker.update!(preferences: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
-          .to raise_error(Mongoid::Errors::DocumentNotFound)
-        expect(victim_preference.reload.name).to eq('Private')
-      end
-    end
-  end
 end

data/spec/mongoid/attributes_spec.rb

@@ -393,11 +393,10 @@ describe Mongoid::Attributes do
         end
 
         context "when reloaded" do
+          config_override :raise_not_found_error, false
 
           before do
-            Mongoid.raise_not_found_error = false
             person.reload
-            Mongoid.raise_not_found_error = true
           end
 
           it "returns the default value" do
@@ -1030,14 +1029,13 @@ describe Mongoid::Attributes do
       end
 
       context "when the attribute does not exist" do
+        config_override :raise_not_found_error, false
 
         before do
           person.collection
             .find({ _id: person.id })
             .update_one({ "$unset" => { age: 1 }})
-          Mongoid.raise_not_found_error = false
           person.reload
-          Mongoid.raise_not_found_error = true
         end
 
         it "returns the default value" do
@@ -1161,14 +1159,13 @@ describe Mongoid::Attributes do
       end
 
       context "when the attribute does not exist" do
+        config_override :raise_not_found_error, false
 
         before do
           person.collection
             .find({ _id: person.id })
             .update_one({ "$unset" => { age: 1 }})
-          Mongoid.raise_not_found_error = false
           person.reload
-          Mongoid.raise_not_found_error = true
         end
 
         it "returns true" do
@@ -2711,31 +2708,4 @@ describe Mongoid::Attributes do
       catalog.set_field.should == Set.new([ 1, 2 ])
     end
   end
-
-  context 'when an embedded field has a capitalized store_as name' do
-    let(:person) { Person.new(Purse: { brand: 'Gucci' }) }
-
-    it 'sets the value' do
-      expect(person.purse.brand).to eq('Gucci')
-    end
-
-    it 'saves successfully' do
-      expect(person.save!).to eq(true)
-    end
-
-    context 'when persisted' do
-      before do
-        person.save!
-        person.reload
-      end
-
-      it 'persists the value' do
-        expect(person.reload.purse.brand).to eq('Gucci')
-      end
-
-      it 'uses the correct key in the database' do
-        expect(person.collection.find(_id: person.id).first['Purse']['_id']).to eq(person.purse.id)
-      end
-    end
-  end
 end

data/spec/mongoid/changeable_spec.rb

@@ -476,6 +476,188 @@ describe Mongoid::Changeable do
         end
       end
     end
+
+    context "when including key word args" do
+
+      let(:person) { Person.new }
+
+      context "when only including from" do
+
+        context "when the object has not changed" do
+
+          it "returns false" do
+            expect(person.send(:attribute_changed?, :score, from: nil)).to be false
+          end
+
+          it "returns false using (attribute)_changed?" do
+            expect(person.score_changed?(from: nil)).to be false
+          end
+        end
+
+        context "when the object has changed from the wrong item" do
+
+          before do
+            person.score = 2
+          end
+
+          it "returns false" do
+            expect(person.send(:attribute_changed?, :score, from: 1)).to be false
+          end
+
+          it "returns false using (attribute)_changed?" do
+            expect(person.score_changed?(from: 1)).to be false
+          end
+        end
+
+        context "when the object has changed from the correct item" do
+
+          before do
+            person.score = 2
+          end
+
+          it "returns true" do
+            expect(person.send(:attribute_changed?, :score, from: nil)).to be true
+          end
+
+          it "returns true using (attribute)_changed?" do
+            expect(person.score_changed?(from: nil)).to be true
+          end
+        end
+      end
+
+      context "when only including to" do
+
+        context "when the object has not changed" do
+
+          it "returns false" do
+            expect(person.send(:attribute_changed?, :score, to: nil)).to be false
+          end
+
+          it "returns false using (attribute)_changed?" do
+            expect(person.score_changed?(to: nil)).to be false
+          end
+        end
+
+        context "when the object has changed to the wrong item" do
+
+          before do
+            person.score = 2
+          end
+
+          it "returns false" do
+            expect(person.send(:attribute_changed?, :score, to: 1)).to be false
+          end
+
+          it "returns false using (attribute)_changed?" do
+            expect(person.score_changed?(to: 1)).to be false
+          end
+        end
+
+        context "when the object has changed to the correct item" do
+
+          before do
+            person.score = 2
+          end
+
+          it "returns true" do
+            expect(person.send(:attribute_changed?, :score, to: 2)).to be true
+          end
+
+          it "returns true using (attribute)_changed?" do
+            expect(person.score_changed?(to: 2)).to be true
+          end
+        end
+      end
+
+      context "when including from and to" do
+
+        context "when the object has not changed" do
+
+          it "returns false" do
+            expect(person.send(:attribute_changed?, :score, from: nil, to: nil)).to be false
+          end
+
+          it "returns false using (attribute)_changed?" do
+            expect(person.score_changed?(from: nil, to: nil)).to be false
+          end
+        end
+
+        context "when only the from is correct" do
+
+          before do
+            person.score = 2
+          end
+
+          it "returns false" do
+            expect(person.send(:attribute_changed?, :score, from: nil, to: 3)).to be false
+          end
+
+          it "returns false using (attribute)_changed?" do
+            expect(person.score_changed?(from: nil, to: 3)).to be false
+          end
+        end
+
+        context "when only the to is correct" do
+
+          before do
+            person.score = 2
+          end
+
+          it "returns false" do
+            expect(person.send(:attribute_changed?, :score, from: 1, to: 2)).to be false
+          end
+
+          it "returns false using (attribute)_changed?" do
+            expect(person.score_changed?(from: 1, to: 2)).to be false
+          end
+        end
+
+        context "when the from and to are correct" do
+
+          before do
+            person.score = 2
+          end
+
+          it "returns true" do
+            expect(person.send(:attribute_changed?, :score, from: nil, to: 2)).to be true
+          end
+
+          it "returns true using (attribute)_changed?" do
+            expect(person.score_changed?(from: nil, to: 2)).to be true
+          end
+        end
+
+        context "when value is mongoized" do
+
+          before do
+            person.score = "2"
+          end
+
+          it "returns true with mongoized value" do
+            expect(person.send(:attribute_changed?, :score, from: nil, to: 2)).to be true
+          end
+
+          it "returns true with mongoized value using (attribute)_changed?" do
+            expect(person.score_changed?(from: nil, to: 2)).to be true
+          end
+        end
+
+        context "when value is mongoized" do
+
+          before do
+            person.score = "2"
+          end
+
+          it "returns false with unmongoized value" do
+            expect(person.send(:attribute_changed?, :score, from: nil, to: "2")).to be false
+          end
+
+          it "returns false with unmongoized value using (attribute)_changed?" do
+            expect(person.score_changed?(from: nil, to: "2")).to be false
+          end
+        end
+      end
+    end
   end
 
   describe "#attribute_changed_from_default?" do
@@ -1167,20 +1349,10 @@ describe Mongoid::Changeable do
 
       context "when the document is embedded" do
 
-        let(:person) do
-          Person.instantiate(title: "Grand Poobah")
-        end
+        let(:person) { Person.create(title: "Grand Poobah") }
+        let(:address) { person.addresses.create(street: "Oxford St") }
 
-        let(:address) do
-          Address.instantiate(street: "Oxford St")
-        end
-
-        before do
-          person.addresses << address
-          person.instance_variable_set(:@new_record, false)
-          address.instance_variable_set(:@new_record, false)
-          address.street = "Bond St"
-        end
+        before { address.street = "Bond St" }
 
         it "returns a hash of field names and new values" do
           expect(address.setters).to eq(
@@ -1189,17 +1361,9 @@ describe Mongoid::Changeable do
         end
 
         context "when the document is embedded multiple levels" do
-
-          let(:location) do
-            Location.new(name: "Home")
-          end
-
-          before do
-            location.instance_variable_set(:@new_record, false)
-            address.locations << location
-            location.name = "Work"
-          end
-
+          let(:location) { address.locations.create(name: "Home") }
+          before { location.name = "Work" }
+          
           it "returns the proper hash with locations" do
             expect(location.setters).to eq(
               { "addresses.0.locations.0.name" => "Work" }
@@ -1479,6 +1643,117 @@ describe Mongoid::Changeable do
     end
   end
 
+  describe '#attribute_before_last_save' do
+    let(:person) do
+      Person.create!(title: "Grand Poobah")
+    end
+
+    before do
+      person.title = "Captain Obvious"
+    end
+
+    context "when the document has been saved" do
+      before do
+        person.save!
+      end
+
+      it "returns the changes" do
+        expect(person.attribute_before_last_save(:title)).to eq("Grand Poobah")
+        expect(person.title_before_last_save).to eq("Grand Poobah")
+      end
+    end
+
+    context "when the document has not been saved" do
+      it "returns no changes" do
+        expect(person.attribute_before_last_save(:title)).to be_nil
+        expect(person.title_before_last_save).to be_nil
+      end
+    end
+  end
+
+  describe '#saved_change_to_attribute' do
+    let(:person) do
+      Person.create!(title: "Grand Poobah")
+    end
+
+    before do
+      person.title = "Captain Obvious"
+    end
+
+    context "when the document has been saved" do
+      before do
+        person.save!
+      end
+
+      it "returns the changes" do
+        expect(person.saved_change_to_attribute(:title)).to eq(["Grand Poobah", "Captain Obvious"])
+        expect(person.saved_change_to_title).to eq(["Grand Poobah", "Captain Obvious"])
+      end
+    end
+
+    context "when the document has not been saved" do
+      it "returns changes for the previous save" do
+        expect(person.saved_change_to_attribute(:title)).to eq([nil, "Grand Poobah"])
+        expect(person.saved_change_to_title).to eq([nil, "Grand Poobah"])
+      end
+    end
+  end
+
+  describe '#saved_change_to_attribute?' do
+    context "when the document has been saved" do
+      let(:person) do
+        Person.create!(title: "Grand Poobah")
+      end
+
+      before do
+        person.title = "Captain Obvious"
+      end
+
+      before do
+        person.save!
+      end
+
+      it "detects the changes" do
+        expect(person.saved_change_to_attribute?(:title)).to be_truthy
+        expect(person.saved_change_to_attribute?(:title, from: "Grand Poobah")).to be_truthy
+        expect(person.saved_change_to_attribute?(:title, to: "Captain Obvious")).to be_truthy
+        expect(person.saved_change_to_attribute?(:title, from: "Grand Poobah", to: "Captain Obvious")).to be_truthy
+        expect(person.saved_change_to_title?(from: "Grand Poobah", to: "Captain Obvious")).to be_truthy
+        expect(person.saved_change_to_attribute?(:age)).to be_falsey
+        expect(person.saved_change_to_age?).to be_falsey
+      end
+    end
+
+    context "when the document has not been saved" do
+      let(:person) do
+        Person.new(title: "Grand Poobah")
+      end
+
+      it "returns changes for the previous save" do
+        expect(person.saved_change_to_attribute?(:title)).to be_falsey
+        expect(person.saved_change_to_title?).to be_falsey
+      end
+    end
+  end
+
+  describe '#will_save_change_to_attribute?' do
+    let(:person) do
+      Person.create!(title: "Grand Poobah")
+    end
+
+    before do
+      person.title = "Captain Obvious"
+    end
+
+    it 'correctly detects changes' do
+      expect(person.will_save_change_to_attribute?(:title)).to eq(true)
+      expect(person.will_save_change_to_title?).to eq(true)
+      expect(person.will_save_change_to_attribute?(:score)).to eq(false)
+      expect(person.will_save_change_to_score?).to eq(false)
+    end
+
+  end
+
   context "when fields have been defined pre-dirty inclusion" do
 
     let(:document) do