mongoid 3.1.7 → 4.0.2

data/spec/mongoid/relations/touchable_spec.rb

@@ -0,0 +1,333 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Touchable do
+
+  describe "#touch" do
+
+    context "when the document is embedded" do
+
+      let(:band) do
+        Band.create(name: "Placebo")
+      end
+
+      let(:label) do
+        band.create_label(name: "Mute", updated_at: 10.days.ago)
+      end
+
+      before do
+        label.touch
+      end
+
+      it "updates the updated_at timestamp" do
+        expect(label.updated_at).to be_within(1).of(Time.now)
+      end
+
+      it "persists the changes" do
+        expect(label.reload.updated_at).to be_within(1).of(Time.now)
+      end
+    end
+
+    context "when no relations have touch options" do
+
+      context "when no updated at is defined" do
+
+        let(:person) do
+          Person.create
+        end
+
+        context "when no attribute is provided" do
+
+          let!(:touched) do
+            person.touch
+          end
+
+          it "returns true" do
+            expect(touched).to be true
+          end
+
+          it "does not set the updated at field" do
+            expect(person[:updated_at]).to be_nil
+          end
+        end
+
+        context "when an attribute is provided" do
+
+          let!(:touched) do
+            person.touch(:lunch_time)
+          end
+
+          it "sets the attribute to the current time" do
+            expect(person.lunch_time).to be_within(5).of(Time.now)
+          end
+
+          it "persists the change" do
+            expect(person.reload.lunch_time).to be_within(5).of(Time.now)
+          end
+
+          it "returns true" do
+            expect(touched).to be true
+          end
+        end
+
+        context "when an attribute alias is provided" do
+
+          let!(:touched) do
+            person.touch(:aliased_timestamp)
+          end
+
+          it "sets the attribute to the current time" do
+            expect(person.aliased_timestamp).to be_within(5).of(Time.now)
+          end
+
+          it "persists the change" do
+            expect(person.reload.aliased_timestamp).to be_within(5).of(Time.now)
+          end
+
+          it "returns true" do
+            expect(touched).to be true
+          end
+        end
+      end
+
+      context "when an updated at is defined" do
+
+        let!(:agent) do
+          Agent.create(updated_at: 2.days.ago)
+        end
+
+        context "when no attribute is provided" do
+
+          let!(:touched) do
+            agent.touch
+          end
+
+          it "sets the updated at to the current time" do
+            expect(agent.updated_at).to be_within(5).of(Time.now)
+          end
+
+          it "persists the change" do
+            expect(agent.reload.updated_at).to be_within(5).of(Time.now)
+          end
+
+          it "returns true" do
+            expect(touched).to be true
+          end
+
+          it "keeps changes for next callback" do
+            expect(agent.changes).to_not be_empty
+          end
+        end
+
+        context "when an attribute is provided" do
+
+          let!(:touched) do
+            agent.touch(:dob)
+          end
+
+          it "sets the updated at to the current time" do
+            expect(agent.updated_at).to be_within(5).of(Time.now)
+          end
+
+          it "sets the attribute to the current time" do
+            expect(agent.dob).to be_within(5).of(Time.now)
+          end
+
+          it "sets both attributes to the exact same time" do
+            expect(agent.updated_at).to eq(agent.dob)
+          end
+
+          it "persists the updated at change" do
+            expect(agent.reload.updated_at).to be_within(5).of(Time.now)
+          end
+
+          it "persists the attribute change" do
+            expect(agent.reload.dob).to be_within(5).of(Time.now)
+          end
+
+          it "returns true" do
+            expect(touched).to be true
+          end
+
+          it "keeps changes for next callback" do
+            expect(agent.changes).to_not be_empty
+          end
+        end
+      end
+
+      context "when record is new" do
+
+        let(:agent) do
+          Agent.new(updated_at: 2.days.ago)
+        end
+
+        context "when no attribute is provided" do
+
+          let!(:touched) do
+            agent.touch
+          end
+
+          it "returns false" do
+            expect(touched).to be false
+          end
+        end
+
+        context "when an attribute is provided" do
+
+          let!(:touched) do
+            agent.touch(:dob)
+          end
+
+          it "returns false" do
+            expect(touched).to be false
+          end
+        end
+      end
+
+      context "when creating the child" do
+
+        let(:time) do
+          Time.utc(2012, 4, 3, 12)
+        end
+
+        let(:jar) do
+          Jar.new(_id: 1, updated_at: time).tap do |jar|
+            jar.save!
+          end
+        end
+
+        let!(:cookie) do
+          jar.cookies.create!(updated_at: time)
+        end
+
+        it "does not touch the parent" do
+          expect(jar.updated_at).to eq(time)
+        end
+      end
+    end
+
+    context "when relations have touch options" do
+
+      context "when the relation is a parent of an embedded doc" do
+
+        let(:page) do
+          WikiPage.create(title: "test")
+        end
+
+        let!(:edit) do
+          page.edits.create
+        end
+
+        before do
+          page.unset(:updated_at)
+          edit.touch
+        end
+
+        it "touches the parent document" do
+          expect(page.updated_at).to be_within(5).of(Time.now)
+        end
+      end
+
+      context "when the relation is nil" do
+
+        let!(:agent) do
+          Agent.create
+        end
+
+        context "when the relation autobuilds" do
+
+          let!(:touched) do
+            agent.touch
+          end
+
+          it "does nothing to the relation" do
+            expect(agent.instance_variable_get(:@agency)).to be_nil
+          end
+        end
+      end
+
+      context "when the relation is not nil" do
+
+        let!(:agent) do
+          Agent.create
+        end
+
+        let!(:agency) do
+          agent.create_agency.tap do |a|
+            a.unset(:updated_at)
+          end
+        end
+
+        let!(:touched) do
+          agent.touch
+        end
+
+        it "sets the parent updated at to the current time" do
+          expect(agency.updated_at).to be_within(5).of(Time.now)
+        end
+
+        it "persists the change" do
+          expect(agency.reload.updated_at).to be_within(5).of(Time.now)
+        end
+      end
+
+      context "when creating the child" do
+
+        let!(:agency) do
+          Agency.create
+        end
+
+        let!(:updated) do
+          agency.updated_at
+        end
+
+        let!(:agent) do
+          agency.agents.create
+        end
+
+        it "updates the parent's updated at" do
+          expect(agency.updated_at).to_not eq(updated)
+        end
+      end
+
+      context "when modifying the child" do
+
+        let!(:agency) do
+          Agency.create
+        end
+
+        let!(:agent) do
+          agency.agents.create(number: '1')
+        end
+
+        it "updates the parent's updated at" do
+          expect {
+            agent.update_attributes(number: '2')
+          }.to change { agency.updated_at }
+        end
+      end
+
+      context "when destroying the child" do
+
+        let!(:agency) do
+          Agency.create
+        end
+
+        let!(:agent) do
+          agency.agents.create
+        end
+
+        let!(:updated) do
+          agency.updated_at
+        end
+
+        before do
+          agent.destroy
+        end
+
+        it "updates the parent's updated at" do
+          expect(agency.updated_at).to_not eq(updated)
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/relations_spec.rb

@@ -5,9 +5,10 @@ describe Mongoid::Relations do
   before(:all) do
     Person.field(
       :_id,
-      type: Moped::BSON::ObjectId,
+      type: BSON::ObjectId,
       pre_processed: true,
-      default: ->{ Moped::BSON::ObjectId.new }
+      default: ->{ BSON::ObjectId.new },
+      overwrite: true
     )
   end
 
@@ -28,7 +29,7 @@ describe Mongoid::Relations do
       end
 
       it "returns true" do
-        document.should be_embedded
+        expect(document).to be_embedded
       end
     end
 
@@ -37,14 +38,14 @@ describe Mongoid::Relations do
       context "when the document is embedded in" do
 
         it "returns true" do
-          document.should be_embedded
+          expect(document).to be_embedded
         end
       end
 
       context "when the document class is not embedded in" do
 
         it "returns false" do
-          person.should_not be_embedded
+          expect(person).to_not be_embedded
         end
       end
     end
@@ -54,7 +55,7 @@ describe Mongoid::Relations do
       context "when the document has no parent" do
 
         it "returns false" do
-          Item.should_not be_embedded
+          expect(Item).to_not be_embedded
         end
       end
     end
@@ -64,7 +65,7 @@ describe Mongoid::Relations do
       context "when the document has a parent" do
 
         it "returns true" do
-          SubItem.should be_embedded
+          expect(SubItem).to be_embedded
         end
       end
     end
@@ -83,7 +84,7 @@ describe Mongoid::Relations do
       end
 
       it "returns true" do
-        address.should be_an_embedded_many
+        expect(address).to be_an_embedded_many
       end
     end
 
@@ -94,7 +95,7 @@ describe Mongoid::Relations do
       end
 
       it "returns false" do
-        name.should_not be_an_embedded_many
+        expect(name).to_not be_an_embedded_many
       end
     end
   end
@@ -112,7 +113,7 @@ describe Mongoid::Relations do
       end
 
       it "returns true" do
-        name.should be_an_embedded_one
+        expect(name).to be_an_embedded_one
       end
     end
 
@@ -123,7 +124,7 @@ describe Mongoid::Relations do
       end
 
       it "returns false" do
-        address.should_not be_an_embedded_one
+        expect(address).to_not be_an_embedded_one
       end
     end
   end
@@ -141,7 +142,7 @@ describe Mongoid::Relations do
       end
 
       it "returns true" do
-        post.should be_a_referenced_many
+        expect(post).to be_a_referenced_many
       end
     end
 
@@ -152,7 +153,7 @@ describe Mongoid::Relations do
       end
 
       it "returns false" do
-        game.should_not be_a_referenced_many
+        expect(game).to_not be_a_referenced_many
       end
     end
   end
@@ -170,7 +171,7 @@ describe Mongoid::Relations do
       end
 
       it "returns true" do
-        game.should be_a_referenced_one
+        expect(game).to be_a_referenced_one
       end
     end
 
@@ -181,7 +182,7 @@ describe Mongoid::Relations do
       end
 
       it "returns false" do
-        post.should_not be_a_referenced_one
+        expect(post).to_not be_a_referenced_one
       end
     end
   end

data/spec/mongoid/{reloading_spec.rb → reloadable_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Reloading do
+describe Mongoid::Reloadable do
 
   describe "#reload" do
 
@@ -19,11 +19,11 @@ describe Mongoid::Reloading do
 
       it "reloads the object attributes from the db" do
         person.reload
-        person.age.should eq(35)
+        expect(person.age).to eq(35)
       end
 
       it "reload should return self" do
-        person.reload.should eq(from_db)
+        expect(person.reload).to eq(from_db)
       end
     end
 
@@ -42,11 +42,11 @@ describe Mongoid::Reloading do
 
       it "reloads the object attributes from the db" do
         account.reload
-        account.number.should eq("1001")
+        expect(account.number).to eq("1001")
       end
 
       it "reload should return self" do
-        account.reload.should eq(from_db)
+        expect(account.reload).to eq(from_db)
       end
     end
 
@@ -62,7 +62,7 @@ describe Mongoid::Reloading do
       end
 
       it "runs the callback" do
-        book.chapters.should eq(5)
+        expect(book.chapters).to eq(5)
       end
     end
 
@@ -78,11 +78,11 @@ describe Mongoid::Reloading do
       end
 
       it "resets the dirty modifications" do
-        person.changes.should be_empty
+        expect(person.changes).to be_empty
       end
 
       it "resets attributes_before_type_cast" do
-        person.attributes_before_type_cast.should be_empty
+        expect(person.attributes_before_type_cast).to be_empty
       end
     end
 
@@ -123,15 +123,15 @@ describe Mongoid::Reloading do
           end
 
           it "reloads the embedded document attributes" do
-            reloaded.number.should eq(3)
+            expect(reloaded.number).to eq(3)
           end
 
           it "reloads the reference on the parent" do
-            person.addresses.first.should eq(reloaded)
+            expect(person.addresses.first).to eq(reloaded)
           end
 
           it "retains the relation to the parent" do
-            reloaded.addressable.should eq(person)
+            expect(reloaded.addressable).to eq(person)
           end
         end
 
@@ -151,15 +151,15 @@ describe Mongoid::Reloading do
           end
 
           it "reloads the embedded document attributes" do
-            reloaded.last_name.should eq("Vicious")
+            expect(reloaded.last_name).to eq("Vicious")
           end
 
           it "reloads the reference on the parent" do
-            person.name.should eq(reloaded)
+            expect(person.name).to eq(reloaded)
           end
 
           it "retains the relation to the parent" do
-            reloaded.namable.should eq(person)
+            expect(reloaded.namable).to eq(person)
           end
         end
       end
@@ -184,15 +184,15 @@ describe Mongoid::Reloading do
         end
 
         it "reloads the embedded document attributes" do
-          reloaded.name.should eq("work")
+          expect(reloaded.name).to eq("work")
         end
 
         it "reloads the reference on the parent" do
-          address.locations.first.should eq(reloaded)
+          expect(address.locations.first).to eq(reloaded)
         end
 
         it "reloads the reference on the root" do
-          person.addresses.first.locations.first.should eq(reloaded)
+          expect(person.addresses.first.locations.first).to eq(reloaded)
         end
       end
     end
@@ -214,7 +214,7 @@ describe Mongoid::Reloading do
       end
 
       it "reloads the association" do
-        person.addresses.should be_empty
+        expect(person.addresses).to be_empty
       end
     end
 
@@ -237,7 +237,7 @@ describe Mongoid::Reloading do
         end
 
         it "reloads the association" do
-          person.game.score.should eq(75)
+          expect(person.game.score).to eq(75)
         end
       end
 
@@ -256,49 +256,32 @@ describe Mongoid::Reloading do
           end
 
           it "reloads the association" do
-            game.person.title.should eq("Mam")
+            expect(game.person.title).to eq("Mam")
           end
         end
+      end
+    end
 
-        context "when the identity map is enabled" do
-
-          before do
-            Mongoid.identity_map_enabled = true
-          end
-
-          after do
-            Mongoid.identity_map_enabled = false
-          end
-
-          context "when the relation type changes" do
-
-            let!(:doctor) do
-              Doctor.create
-            end
-
-            let!(:game) do
-              Game.create(:person => doctor)
-            end
-
-            before do
-              doctor.becomes(Doktor)
-            end
+    context "when overriding #id alias" do
 
-            context "when reloading the base" do
+      let!(:object) do
+        IdKey.create(key: 'foo')
+      end
 
-              it "reloads the correct type of document" do
-                game.reload.person.should be_a(Doktor)
-              end
-            end
+      let!(:from_db) do
+        IdKey.find(object._id).tap do |object|
+          object.key = 'bar'
+          object.save
+        end
+      end
 
-            context "when reloading the association" do
+      it "reloads the object attributes from the db" do
+        object.reload
+        expect(object.key).to eq('bar')
+      end
 
-              it "reloads the correct type of document" do
-                game.person(true).should be_a(Doktor)
-              end
-            end
-          end
-        end
+      it "reload should return self" do
+        expect(object.reload).to eq(from_db)
       end
     end
   end