mongoid 4.0.0 → 4.0.2

data/spec/mongoid/attributes_spec.rb

@@ -248,6 +248,17 @@ describe Mongoid::Attributes do
     it "delegates to #id" do
       expect(person._id).to eq(person.id)
     end
+
+    context "when #id alias is overridden" do
+
+      let(:object) do
+        IdKey.new(key: 'foo')
+      end
+
+      it "delegates to another method" do
+        expect(object.id).to eq(object.key)
+      end
+    end
   end
 
   describe "#_id=" do
@@ -314,6 +325,19 @@ describe Mongoid::Attributes do
           expect(person.id).to eq(2)
         end
       end
+
+      context "when #id= alias is overridden" do
+
+        let(:object) do
+          IdKey.new(key: 'foo')
+        end
+
+        it "delegates to another method" do
+          object.id = 'bar'
+          expect(object.id).to eq('bar')
+        end
+      end
+
     end
 
     context "when using string ids" do
@@ -853,6 +877,18 @@ describe Mongoid::Attributes do
         expect(person.attribute_present?(:title)).to be false
       end
     end
+
+    context "when the attribute is not on only list" do
+
+      before { Person.create }
+      let(:person) do
+        Person.only(:id).first
+      end
+
+      it "return false" do
+        expect(person.attribute_present?(:foobar)).to be false
+      end
+    end
   end
 
   describe "#has_attribute?" do

data/spec/mongoid/contextual/atomic_spec.rb

@@ -103,10 +103,8 @@ describe Mongoid::Contextual::Atomic do
         expect(depeche_mode.reload.likes).to eq(12)
       end
 
-      if mongodb_version > "2.5"
-        it "does not error on non initialized fields" do
-          expect(smiths.reload.likes).to eq(0)
-        end
+      it "does not error on non initialized fields" do
+        expect(smiths.reload.likes).to eq(0)
       end
     end
 
@@ -120,10 +118,8 @@ describe Mongoid::Contextual::Atomic do
         expect(depeche_mode.reload.likes).to eq(61)
       end
 
-      if mongodb_version > "2.5"
-        it "does not error on non initialized fields" do
-          expect(smiths.reload.likes).to eq(13)
-        end
+      it "does not error on non initialized fields" do
+        expect(smiths.reload.likes).to eq(13)
       end
     end
 
@@ -137,13 +133,11 @@ describe Mongoid::Contextual::Atomic do
         expect(depeche_mode.reload.likes).to eq(14)
       end
 
-      if mongodb_version > "2.5"
-        it "does not error on non initialized fields" do
-          expect(smiths.reload.likes).to eq(10)
-        end
+      it "does not error on non initialized fields" do
+        expect(smiths.reload.likes).to eq(10)
       end
     end
-  end
+  end if mongodb_version > "2.5"
 
   describe "#inc" do
 

data/spec/mongoid/contextual/memory_spec.rb

@@ -926,8 +926,13 @@ describe Mongoid::Contextual::Memory do
         Address.new(street: "lenau", number: 5, name: "lenau")
       end
 
+      let(:kampuchea_krom) do
+        Address.new(street: "kampuchea krom", number: 5, name: "kampuchea krom")
+      end
+
       before do
         criteria.documents.unshift(lenau)
+        criteria.documents.unshift(kampuchea_krom)
       end
 
       context "when the sort is ascending" do
@@ -937,7 +942,7 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "sorts the documents" do
-          expect(context.entries).to eq([ friedel, lenau, pfluger, hobrecht ])
+          expect(context.entries).to eq([ friedel, kampuchea_krom, lenau, pfluger, hobrecht ])
         end
 
         it "returns the context" do
@@ -952,7 +957,7 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "sorts the documents" do
-          expect(context.entries).to eq([ hobrecht, pfluger, lenau, friedel ])
+          expect(context.entries).to eq([ hobrecht, pfluger, lenau, kampuchea_krom, friedel ])
         end
 
         it "returns the context" do

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -934,12 +934,9 @@ describe Mongoid::Criteria::Modifiable do
 
       context "when the relation is a references many" do
 
-        let!(:post_one) do
-          person.posts.create(title: "First")
-        end
-
-        let!(:post_two) do
-          person.posts.create(title: "Second")
+        before do
+          person.posts.create!(title: "First")
+          person.posts.create!(title: "Second")
         end
 
         context "when updating the relation directly" do
@@ -948,12 +945,12 @@ describe Mongoid::Criteria::Modifiable do
             person.posts.update(title: "London")
           end
 
-          let!(:from_db) do
+          let(:from_db) do
             Person.first
           end
 
           it "updates the first document" do
-            expect(from_db.posts.first.title).to eq("London")
+            expect(from_db.posts.map(&:title)).to eq(["London", "Second"])
           end
 
           it "does not update the last document" do

data/spec/mongoid/criteria_spec.rb

@@ -1371,6 +1371,77 @@ describe Mongoid::Criteria do
 
     context "when including a belongs to relation" do
 
+      context "when the criteria is from the root" do
+
+        let!(:person_two) do
+          Person.create(age: 2)
+        end
+
+        let!(:post_one) do
+          person.posts.create(title: "one")
+        end
+
+        let!(:post_two) do
+          person_two.posts.create(title: "two")
+        end
+
+        context "when calling first" do
+
+          let(:criteria) do
+            Post.includes(:person)
+          end
+
+          let!(:document) do
+            criteria.first
+          end
+
+          it "eager loads the first document" do
+            expect_query(0) do
+              expect(document.person).to eq(person)
+            end
+          end
+
+          it "does not eager load the last document" do
+            doc = criteria.last
+            expect_query(1) do
+              expect(doc.person).to eq(person_two)
+            end
+          end
+
+          it "returns the first document" do
+            expect(document).to eq(post_one)
+          end
+        end
+
+        context "when calling last" do
+
+          let!(:criteria) do
+            Post.includes(:person)
+          end
+
+          let!(:document) do
+            criteria.last
+          end
+
+          it "eager loads the last document" do
+            expect_query(0) do
+              expect(document.person).to eq(person_two)
+            end
+          end
+
+          it "does not eager load the first document" do
+            doc = criteria.first
+            expect_query(1) do
+              expect(doc.person).to eq(person)
+            end
+          end
+
+          it "returns the last document" do
+            expect(document).to eq(post_two)
+          end
+        end
+      end
+
       context "when the criteria is from an embedded relation" do
 
         let(:peep) do
@@ -1495,77 +1566,6 @@ describe Mongoid::Criteria do
           end
         end
       end
-
-      context "when the criteria is from the root" do
-
-        let!(:person_two) do
-          Person.create(age: 2)
-        end
-
-        let!(:post_one) do
-          person.posts.create(title: "one")
-        end
-
-        let!(:post_two) do
-          person_two.posts.create(title: "two")
-        end
-
-        context "when calling first" do
-
-          let(:criteria) do
-            Post.includes(:person)
-          end
-
-          let!(:document) do
-            criteria.first
-          end
-
-          it "eager loads the first document" do
-            expect_query(0) do
-              expect(document.person).to eq(person)
-            end
-          end
-
-          it "does not eager load the last document" do
-            doc = criteria.last
-            expect_query(1) do
-              expect(doc.person).to eq(person_two)
-            end
-          end
-
-          it "returns the first document" do
-            expect(document).to eq(post_one)
-          end
-        end
-
-        context "when calling last" do
-
-          let!(:criteria) do
-            Post.includes(:person)
-          end
-
-          let!(:document) do
-            criteria.last
-          end
-
-          it "eager loads the last document" do
-            expect_query(0) do
-              expect(document.person).to eq(person_two)
-            end
-          end
-
-          it "does not eager load the first document" do
-            doc = criteria.first
-            expect_query(1) do
-              expect(doc.person).to eq(person)
-            end
-          end
-
-          it "returns the last document" do
-            expect(document).to eq(post_two)
-          end
-        end
-      end
     end
 
     context "when providing inclusions to the default scope" do
@@ -2851,6 +2851,17 @@ describe Mongoid::Criteria do
       end
     end
 
+    context "when plucking existent and non-existent fields" do
+
+      let(:plucked) do
+        Band.all.pluck(:id, :fooz)
+      end
+
+      it "returns nil for the field that doesnt exist" do
+        expect(plucked).to eq([[depeche.id, nil], [tool.id, nil], [photek.id, nil] ])
+      end
+    end
+
     context "when plucking a field that doesnt exist" do
 
       context "when pluck one field" do
@@ -2859,8 +2870,8 @@ describe Mongoid::Criteria do
           Band.all.pluck(:foo)
         end
 
-        it "returns a empty array" do
-          expect(plucked).to eq([])
+        it "returns a array with nil values" do
+          expect(plucked).to eq([nil, nil, nil])
         end
       end
 
@@ -2870,8 +2881,8 @@ describe Mongoid::Criteria do
           Band.all.pluck(:foo, :bar)
         end
 
-        it "returns a empty array" do
-          expect(plucked).to eq([[], [], []])
+        it "returns a nil arrays" do
+          expect(plucked).to eq([[nil, nil], [nil, nil], [nil, nil]])
         end
       end
     end

data/spec/mongoid/document_spec.rb

@@ -144,7 +144,7 @@ describe Mongoid::Document do
       context "with updated_at" do
 
         let!(:updated_at) do
-          document.updated_at.utc.to_s(:number)
+          document.updated_at.utc.to_s(:nsec)
         end
 
         it "has the id and updated_at key name" do
@@ -182,7 +182,7 @@ describe Mongoid::Document do
       end
 
       let!(:updated_at) do
-        agent.updated_at.utc.to_s(:number)
+        agent.updated_at.utc.to_s(:nsec)
       end
 
       it "has the id and updated_at key name" do
@@ -529,11 +529,15 @@ describe Mongoid::Document do
     context "when the document is not new" do
 
       let(:person) do
-        Person.instantiate("_id" => BSON::ObjectId.new)
+        Person.create!
       end
 
       it "returns the id in an array" do
-        expect(person.to_key).to eq([ person.id ])
+        expect(person.to_key).to eq([ person.id.to_s ])
+      end
+
+      it "can query using the key" do
+        expect(person.id).to eq Person.find(person.to_key).first.id
       end
     end
 
@@ -546,7 +550,7 @@ describe Mongoid::Document do
       end
 
       it "returns the id in an array" do
-        expect(person.to_key).to eq([ person.id ])
+        expect(person.to_key).to eq([ person.id.to_s ])
       end
     end
   end

data/spec/mongoid/extensions_spec.rb

@@ -13,3 +13,17 @@ describe BSON::ObjectId do
     end
   end
 end
+
+describe BSON::Document do
+
+  describe "#symbolize_keys" do
+
+    let(:doc) do
+      described_class.new("foo" => "bar")
+    end
+
+    it "returns key as symbol" do
+      expect(doc.symbolize_keys.keys).to eq [:foo]
+    end
+  end
+end

data/spec/mongoid/findable_spec.rb

@@ -53,6 +53,55 @@ describe Mongoid::Findable do
 
   describe ".find_by" do
 
+    context "when collection is a embeds_many" do
+
+      let(:person) do
+        Person.create(title: "sir")
+      end
+
+      let!(:message) do
+        person.messages.create!(body: 'foo')
+      end
+
+      context "when the document is found" do
+
+        it "returns the document" do
+          expect(person.messages.find_by(body: 'foo')).to eq(message)
+        end
+      end
+
+      context "when the document is not found" do
+
+        context "when raising a not found error" do
+
+          let!(:raise_option) { Mongoid.raise_not_found_error }
+
+          before { Mongoid.raise_not_found_error = true }
+
+          after { Mongoid.raise_not_found_error = raise_option }
+
+          it "raises an error" do
+            expect {
+              person.messages.find_by(body: 'bar')
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context "when raising no error" do
+
+          let!(:raise_option) { Mongoid.raise_not_found_error }
+
+          before { Mongoid.raise_not_found_error = false }
+
+          after { Mongoid.raise_not_found_error = raise_option }
+
+          it "returns nil" do
+            expect(person.messages.find_by(body: 'bar')).to be_nil
+          end
+        end
+      end
+    end
+
     context "when the document is found" do
 
       let!(:person) do
@@ -84,9 +133,11 @@ describe Mongoid::Findable do
 
       context "when raising a not found error" do
 
-        before do
-          Mongoid.raise_not_found_error = true
-        end
+        let!(:raise_option) { Mongoid.raise_not_found_error }
+
+        before { Mongoid.raise_not_found_error = true }
+
+        after { Mongoid.raise_not_found_error = raise_option }
 
         it "raises an error" do
           expect {
@@ -97,13 +148,11 @@ describe Mongoid::Findable do
 
       context "when raising no error" do
 
-        before do
-          Mongoid.raise_not_found_error = false
-        end
+        let!(:raise_option) { Mongoid.raise_not_found_error }
 
-        after do
-          Mongoid.raise_not_found_error = true
-        end
+        before { Mongoid.raise_not_found_error = false }
+
+        after { Mongoid.raise_not_found_error = raise_option }
 
         context "when no block is provided" do
 
@@ -128,6 +177,45 @@ describe Mongoid::Findable do
     end
   end
 
+  describe "find_by!" do
+
+    context "when the document is found" do
+
+      let!(:person) do
+        Person.create(title: "sir")
+      end
+
+      context "when no block is provided" do
+
+        it "returns the document" do
+          expect(Person.find_by!(title: "sir")).to eq(person)
+        end
+      end
+
+      context "when a block is provided" do
+
+        let(:result) do
+          Person.find_by!(title: "sir") do |peep|
+            peep.age = 50
+          end
+        end
+
+        it "yields the returned document" do
+          expect(result.age).to eq(50)
+        end
+      end
+    end
+
+    context "when the document is not found" do
+
+      it "raises an error" do
+        expect {
+          Person.find_by!(ssn: "333-22-1111")
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+  end
+
   [ :first, :one ].each do |method|
 
     describe "##{method}" do
@@ -382,8 +470,8 @@ describe Mongoid::Findable do
         Band.pluck(:follows)
       end
 
-      it "returns an empty array" do
-        expect(plucked).to be_empty
+      it "returns a array with nil values" do
+        expect(plucked).to eq([nil, nil, nil])
       end
     end
   end

data/spec/mongoid/persistable/creatable_spec.rb

@@ -394,6 +394,47 @@ describe Mongoid::Persistable::Creatable do
           end
         end
       end
+
+      context "#find_or_create_by!" do
+
+        before do
+          container.vehicles.find_or_create_by!({ driver_id: driver.id }, Car)
+        end
+
+        it "creates the given type document" do
+          expect(container.vehicles.map(&:class)).to eq([ Car ])
+        end
+
+        it "creates with the given attributes" do
+          expect(container.vehicles.map(&:driver)).to eq([ driver ])
+        end
+
+        it "creates the correct number of documents" do
+          expect(container.vehicles.size).to eq(1)
+        end
+
+        context "when executing with a found document" do
+
+          before do
+            container.vehicles.find_or_create_by!({ driver_id: driver.id }, Car)
+          end
+
+          it "does not create an additional document" do
+            expect(container.vehicles.size).to eq(1)
+          end
+        end
+
+        context "when executing with an additional new document" do
+
+          before do
+            container.vehicles.find_or_create_by!({ driver_id: driver.id }, Truck)
+          end
+
+          it "creates the new additional document" do
+            expect(container.vehicles.size).to eq(2)
+          end
+        end
+      end
     end
   end
 

data/spec/mongoid/persistable/savable_spec.rb

@@ -8,6 +8,14 @@ describe Mongoid::Persistable::Savable do
       Person.create
     end
 
+    let(:contextable_item) do
+      ContextableItem.new
+    end
+
+    let(:persisted_contextable_item) do
+      ContextableItem.create(title: 'sir')
+    end
+
     context "when skipping validation" do
 
       context "when no relations are involved" do
@@ -285,6 +293,35 @@ describe Mongoid::Persistable::Savable do
         }.to raise_error(Mongoid::Errors::ReadonlyDocument)
       end
     end
+
+    context "when validation context isn't assigned" do
+      it "returns true" do
+        expect(contextable_item.save).to be true
+      end
+    end
+
+    context "when validation context exists" do
+      context "on new document" do
+        it "returns true" do
+          contextable_item.title = "sir"
+          expect(contextable_item.save(context: :in_context)).to be true
+        end
+        it "returns false" do
+          expect(contextable_item.save(context: :in_context)).to be false
+        end
+      end
+
+      context "on persisted document" do
+        it "returns true" do
+          persisted_contextable_item.title = "lady"
+          expect(persisted_contextable_item.save(context: :in_context)).to be true
+        end
+        it "returns false" do
+          persisted_contextable_item.title = nil
+          expect(persisted_contextable_item.save(context: :in_context)).to be false
+        end
+      end
+    end
   end
 
   describe "save!" do

data/spec/mongoid/persistable/settable_spec.rb

@@ -136,4 +136,27 @@ describe Mongoid::Persistable::Settable do
       end
     end
   end
+
+  context "when dynamic attributes are not enabled" do
+    let(:account) do
+      Account.create
+    end
+
+    it "raises exception for an unknown attribute " do
+      expect {
+        account.set(somethingnew: "somethingnew")
+      }.to raise_error(Mongoid::Errors::UnknownAttribute)
+    end
+  end
+
+  context "when dynamic attributes enabled" do
+    let(:person) do
+      Person.create
+    end
+
+    it "updates non existing attribute" do
+      person.set(somethingnew: "somethingnew")
+      expect(person.reload.somethingnew).to eq "somethingnew"
+    end
+  end
 end