mongoid 5.0.0 → 5.0.1

data/spec/mongoid/interceptable_spec.rb

@@ -170,6 +170,61 @@ describe Mongoid::Interceptable do
     it "runs after document instantiation" do
       expect(game.name).to eq("Testing")
     end
+
+    context 'when the document is embedded' do
+
+      after do
+        Book.destroy_all
+      end
+
+      let(:book) do
+        book = Book.new({
+          :pages => [
+            {
+              content: "Page 1",
+              notes: [
+                { message: "Page 1 / Note A" },
+                { message: "Page 1 / Note B" }
+              ]
+            },
+            {
+              content: "Page 2",
+              notes: [
+                { message: "Page 2 / Note A" },
+                { message: "Page 2 / Note B" }
+              ]
+            }
+          ]
+        })
+        book.id = '123'
+        book.save
+        book
+      end
+
+      let(:new_message) do
+        'Note C'
+      end
+
+      before do
+        book.pages.each do | page |
+          page.notes.destroy_all
+          page.notes.new(message: new_message)
+          page.save
+        end
+      end
+
+      let(:expected_messages) do
+        book.reload.pages.reduce([]) do |messages, p|
+          messages += p.notes.reduce([]) do |msgs, n|
+            msgs << n.message
+          end
+        end
+      end
+
+      it 'runs the callback on the embedded documents and saves the parent document' do
+        expect(expected_messages.all? { |m| m == new_message }).to be(true)
+      end
+    end
   end
 
   describe ".after_build" do

data/spec/mongoid/persistable/creatable_spec.rb

@@ -393,6 +393,25 @@ describe Mongoid::Persistable::Creatable do
             expect(container.vehicles.size).to eq(2)
           end
         end
+
+        context 'when searching by a Time value' do
+
+          let!(:account) do
+            Account.create!(name: 'test', period_started_at: Time.now.utc)
+          end
+
+          let!(:queried_consumption) do
+            account.consumption_periods.find_or_create_by(started_at: account.period_started_at)
+          end
+
+          before do
+            account.reload
+          end
+
+          it 'does not change the Time value' do
+            expect(queried_consumption).to eq(account.current_consumption)
+          end
+        end
       end
 
       context "#find_or_create_by!" do

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -82,6 +82,35 @@ describe Mongoid::Persistable::Destroyable do
           expect(from_db.addresses).to be_empty
         end
       end
+
+      context 'when removing from a list of embedded documents' do
+
+        context 'when the embedded documents list is reversed in memory' do
+
+          let(:word) do
+            Word.create!(name: 'driver')
+          end
+
+          let(:from_db) do
+            Word.find(word.id)
+          end
+
+          before do
+            word.definitions.find_or_create_by(description: 'database connector')
+            word.definitions.find_or_create_by(description: 'chauffeur')
+            word.definitions = word.definitions.reverse
+            word.definitions.last.destroy
+          end
+
+          it 'removes the embedded document in memory' do
+            expect(word.definitions.size).to eq(1)
+          end
+
+          it 'removes the embedded document in the database' do
+            expect(from_db.definitions.size).to eq(1)
+          end
+        end
+      end
     end
 
     context "when removing deeply embedded documents" do
@@ -188,5 +217,26 @@ describe Mongoid::Persistable::Destroyable do
         end
       end
     end
+
+    context 'when removing a list of embedded documents' do
+
+      context 'when the embedded documents list is reversed in memory' do
+
+        let(:word) do
+          Word.create!(name: 'driver')
+        end
+
+        before do
+          word.definitions.find_or_create_by(description: 'database connector')
+          word.definitions.find_or_create_by(description: 'chauffeur')
+          word.definitions = word.definitions.reverse
+          word.definitions.destroy_all
+        end
+
+        it 'removes all embedded documents' do
+          expect(word.definitions.size).to eq(0)
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/incrementable_spec.rb

@@ -16,7 +16,7 @@ describe Mongoid::Persistable::Incrementable do
           expect(person.score).to eq(90)
         end
 
-        it "sets a nonexistant value" do
+        it "sets a nonexistent value" do
           expect(person.inte).to eq(30)
         end
 
@@ -32,7 +32,7 @@ describe Mongoid::Persistable::Incrementable do
           expect(person.reload.score).to eq(90)
         end
 
-        it "persists a nonexistant inc" do
+        it "persists a nonexistent inc" do
           expect(person.reload.inte).to eq(30)
         end
 
@@ -97,7 +97,7 @@ describe Mongoid::Persistable::Incrementable do
           expect(address.no).to eq(90)
         end
 
-        it "sets a nonexistant value" do
+        it "sets a nonexistent value" do
           expect(address.house).to eq(30)
         end
 
@@ -113,7 +113,7 @@ describe Mongoid::Persistable::Incrementable do
           expect(address.reload.no).to eq(90)
         end
 
-        it "persists a nonexistant inc" do
+        it "persists a nonexistent inc" do
           expect(address.reload.house).to eq(30)
         end
 
@@ -169,5 +169,57 @@ describe Mongoid::Persistable::Incrementable do
         it_behaves_like "an incrementable embedded document"
       end
     end
+
+    context "when the document is embedded in another embedded document" do
+      shared_examples_for "an incrementable embedded document in another embedded document" do
+
+        it "increments a positive value" do
+          expect(second_answer.position).to eq(2)
+        end
+
+        it "persists a positive inc" do
+          expect(second_answer.reload.position).to eq(2)
+        end
+
+        it "clears out dirty changes" do
+          expect(second_answer).to_not be_changed
+        end
+      end
+
+      let(:survey) do
+        Survey.create
+      end
+
+      let(:question) do
+        survey.questions.create(content: 'foo')
+      end
+
+      let!(:first_answer) do
+        question.answers.create(position: 99)
+      end
+
+      let!(:second_answer) do
+        question.answers.create(position: 1)
+      end
+
+      context "when providing string fields" do
+
+        let!(:inc) do
+          second_answer.inc("position" => 1)
+        end
+
+        it_behaves_like "an incrementable embedded document in another embedded document"
+
+      end
+
+      context "when providing symbol fields" do
+
+        let!(:inc) do
+          second_answer.inc(position: 1)
+        end
+
+        it_behaves_like "an incrementable embedded document in another embedded document"
+      end
+    end
   end
 end

data/spec/mongoid/persistable/pushable_spec.rb

@@ -122,6 +122,17 @@ describe Mongoid::Persistable::Pushable do
 
         it_behaves_like "a unique pushable embedded document"
       end
+
+      context "when provided an array of objects" do
+
+        before do
+          person.add_to_set(array: [{ a: 1}, { b: 2}])
+        end
+
+        it 'persists the array of objects' do
+          expect(person.reload.array).to eq([{ 'a' => 1}, { 'b' => 2}])
+        end
+      end
     end
   end
 

data/spec/mongoid/persistable/savable_spec.rb

@@ -83,6 +83,24 @@ describe Mongoid::Persistable::Savable do
             end
           end
         end
+
+        context 'when the embedded document is unchanged' do
+
+          let(:kangaroo) do
+            Kangaroo.new
+          end
+
+          after do
+            Kangaroo.destroy_all
+          end
+
+          it 'only makes one call to the database' do
+            allow(Kangaroo.collection).to receive(:insert).once
+            expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).never
+            kangaroo.build_baby
+            kangaroo.save
+          end
+        end
       end
     end
 
@@ -395,7 +413,7 @@ describe Mongoid::Persistable::Savable do
         end
       end
 
-      it "reads for persistance as a UTC Time" do
+      it "reads for persistence as a UTC Time" do
         expect(user.changes["last_login"].last.class).to eq(Time)
       end
 
@@ -414,7 +432,7 @@ describe Mongoid::Persistable::Savable do
         end
       end
 
-      it "reads for persistance as a UTC Time" do
+      it "reads for persistence as a UTC Time" do
         expect(user.changes["account_expires"].last.class).to eq(Time)
       end
 

data/spec/mongoid/positional_spec.rb

@@ -0,0 +1,221 @@
+require "spec_helper"
+
+describe Mongoid::Positional do
+
+  describe "#positionally" do
+
+    let(:positionable) do
+      Class.new do
+        include Mongoid::Positional
+      end.new
+    end
+
+    let(:updates) do
+      {
+        "$set" => {
+          "field" => "value",
+          "children.0.field" => "value",
+          "children.0.children.1.children.3.field" => "value"
+        },
+        "$pushAll" => {
+          "children.0.children.1.children.3.fields" => [ "value", "value" ]
+        }
+      }
+    end
+
+    context "when a child has an embeds many under an embeds one" do
+
+      context "when selector does not include the embeds one" do
+
+        let(:selector) do
+          { "_id" => 1, "child._id" => 2 }
+        end
+
+        let(:ops) do
+          {
+            "$set" => {
+              "field" => "value",
+              "child.children.1.children.3.field" => "value",
+            }
+          }
+        end
+
+        let(:processed) do
+          positionable.positionally(selector, ops)
+        end
+
+        it "does not do any replacement" do
+          expect(processed).to eq(ops)
+        end
+      end
+
+      context "when selector includes the embeds one" do
+
+        let(:selector) do
+          { "_id" => 1, "child._id" => 2, "child.children._id" => 3 }
+        end
+
+        let(:ops) do
+          {
+            "$set" => {
+              "field" => "value",
+              "child.children.1.children.3.field" => "value",
+            }
+          }
+        end
+
+        let(:expected) do
+          {
+            "$set" => {
+              "field" => "value",
+              "child.children.1.children.3.field" => "value",
+            }
+          }
+        end
+
+        let(:processed) do
+          positionable.positionally(selector, ops)
+        end
+
+        it "does not do any replacement" do
+          expect(processed).to eq(expected)
+        end
+      end
+    end
+
+    context "when the selector has only 1 pair" do
+
+      let(:selector) do
+        { "_id" => 1 }
+      end
+
+      let(:processed) do
+        positionable.positionally(selector, updates)
+      end
+
+      it "does not do any replacement" do
+        expect(processed).to eq(updates)
+      end
+    end
+
+    context "when the selector has 2 pairs" do
+
+      context "when the second pair has an id" do
+
+        let(:selector) do
+          { "_id" => 1, "children._id" => 2 }
+        end
+
+        let(:expected) do
+          {
+            "$set" => {
+              "field" => "value",
+              "children.$.field" => "value",
+              "children.0.children.1.children.3.field" => "value"
+            },
+            "$pushAll" => {
+              "children.0.children.1.children.3.fields" => [ "value", "value" ]
+            }
+          }
+        end
+
+        let(:processed) do
+          positionable.positionally(selector, updates)
+        end
+
+        it "replaces the first index with the positional operator" do
+          expect(processed).to eq(expected)
+        end
+      end
+
+      context "when the second pair has no id" do
+
+        let(:selector) do
+          { "_id" => 1, "children._id" => nil }
+        end
+
+        let(:expected) do
+          {
+            "$set" => {
+              "field" => "value",
+              "children.0.field" => "value",
+              "children.0.children.1.children.3.field" => "value"
+            },
+            "$pushAll" => {
+              "children.0.children.1.children.3.fields" => [ "value", "value" ]
+            }
+          }
+        end
+
+        let(:processed) do
+          positionable.positionally(selector, updates)
+        end
+
+        it "does not replace the index with the positional operator" do
+          expect(processed).to eq(expected)
+        end
+      end
+    end
+
+    context "when the selector has 3 pairs" do
+
+      let(:selector) do
+        { "_id" => 1, "children._id" => 2, "children.0.children._id" => 3 }
+      end
+
+      let(:expected) do
+        {
+          "$set" => {
+            "field" => "value",
+            "children.$.field" => "value",
+            "children.0.children.1.children.3.field" => "value"
+          },
+          "$pushAll" => {
+            "children.0.children.1.children.3.fields" => [ "value", "value" ]
+          }
+        }
+      end
+
+      let(:processed) do
+        positionable.positionally(selector, updates)
+      end
+
+      it "replaces the first index with the positional operator" do
+        expect(processed).to eq(expected)
+      end
+    end
+
+    context "when the selector has 4 pairs" do
+
+      let(:selector) do
+        {
+          "_id" => 1,
+          "children._id" => 2,
+          "children.0.children._id" => 3,
+          "children.0.children.1.children._id" => 4
+        }
+      end
+
+      let(:expected) do
+        {
+          "$set" => {
+            "field" => "value",
+            "children.$.field" => "value",
+            "children.0.children.1.children.3.field" => "value"
+          },
+          "$pushAll" => {
+            "children.0.children.1.children.3.fields" => [ "value", "value" ]
+          }
+        }
+      end
+
+      let(:processed) do
+        positionable.positionally(selector, updates)
+      end
+
+      it "replaces the first index with the positional operator" do
+        expect(processed).to eq(expected)
+      end
+    end
+  end
+end