mongoid_rails4 4.0.0

data/spec/mongoid/persistable/upsertable_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe Mongoid::Persistable::Upsertable do
+
+  describe "#upsert" do
+
+    context "when the document validates on upsert" do
+
+      let(:account) do
+        Account.new(name: "testing")
+      end
+
+      context "when the document is not valid in the upsert context" do
+
+        before do
+          account.upsert
+        end
+
+        it "adds the validation errors" do
+          expect(account.errors[:nickname]).to_not be_empty
+        end
+
+        it "does not upsert the document" do
+          expect(account).to be_a_new_record
+        end
+      end
+    end
+
+    context "when the document is new" do
+
+      let!(:existing) do
+        Band.create(name: "Photek")
+      end
+
+      context "when a matching document exists in the db" do
+
+        let(:updated) do
+          Band.new(name: "Tool") do |band|
+            band.id = existing.id
+          end
+        end
+
+        before do
+          updated.with(safe: true).upsert
+        end
+
+        it "updates the existing document" do
+          expect(existing.reload.name).to eq("Tool")
+        end
+
+        it "flags the document as persisted" do
+          expect(existing).to be_persisted
+        end
+      end
+
+      context "when no matching document exists in the db" do
+
+        let(:insert) do
+          Band.new(name: "Tool")
+        end
+
+        before do
+          insert.with(safe: true).upsert
+        end
+
+        it "inserts a new document" do
+          expect(insert.reload).to eq(insert)
+        end
+
+        it "does not modify any fields" do
+          expect(insert.reload.name).to eq("Tool")
+        end
+
+        it "flags the document as persisted" do
+          expect(insert).to be_persisted
+        end
+      end
+    end
+
+    context "when the document is not new" do
+
+      let!(:existing) do
+        Band.create(name: "Photek")
+      end
+
+      context "when updating fields outside of the id" do
+
+        before do
+          existing.name = "Depeche Mode"
+        end
+
+        let!(:upsert) do
+          existing.upsert
+        end
+
+        it "updates the existing document" do
+          expect(existing.reload.name).to eq("Depeche Mode")
+        end
+
+        it "returns true" do
+          expect(upsert).to be_true
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/persistable_spec.rb

@@ -0,0 +1,206 @@
+require "spec_helper"
+
+describe Mongoid::Persistable do
+
+  describe "#atomically" do
+
+    let(:document) do
+      Band.create(member_count: 0, likes: 60, origin: "London")
+    end
+
+    context "when providing a block" do
+
+      shared_examples_for "an atomically updatable root document" do
+
+        it "performs inc updates" do
+          expect(document.member_count).to eq(10)
+        end
+
+        it "performs bit updates" do
+          expect(document.likes).to eq(12)
+        end
+
+        it "performs set updates" do
+          expect(document.name).to eq("Placebo")
+        end
+
+        it "performs unset updates" do
+          expect(document.origin).to be_nil
+        end
+
+        it "returns true" do
+          expect(update).to be_true
+        end
+
+        it "persists inc updates" do
+          expect(document.reload.member_count).to eq(10)
+        end
+
+        it "persists bit updates" do
+          expect(document.reload.likes).to eq(12)
+        end
+
+        it "persists set updates" do
+          expect(document.reload.name).to eq("Placebo")
+        end
+
+        it "persists unset updates" do
+          expect(document.reload.origin).to be_nil
+        end
+      end
+
+      context "when not chaining the operations" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          Moped::Query.any_instance.should_receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do
+            document.inc(member_count: 10)
+            document.bit(likes: { and: 13 })
+            document.set(name: "Placebo")
+            document.unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+      end
+
+      context "when chaining the operations" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          Moped::Query.any_instance.should_receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do
+            document.
+              inc(member_count: 10).
+              bit(likes: { and: 13 }).
+              set(name: "Placebo").
+              unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+      end
+
+      context "when given multiple operations of the same type" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10, "other_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          Moped::Query.any_instance.should_receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do
+            document.
+              inc(member_count: 10).
+              inc(other_count: 10).
+              bit(likes: { and: 13 }).
+              set(name: "Placebo").
+              unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+
+        it "performs multiple inc updates" do
+          expect(document.other_count).to eq(10)
+        end
+
+        it "persists multiple inc updates" do
+          expect(document.reload.other_count).to eq(10)
+        end
+      end
+
+      context "when expecting the document to be yielded" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          Moped::Query.any_instance.should_receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do |doc|
+            doc.
+              inc(member_count: 10).
+              bit(likes: { and: 13 }).
+              set(name: "Placebo").
+              unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+      end
+    end
+
+    context "when providing no block "do
+
+      it "returns true" do
+        expect(document.atomically).to be_true
+      end
+    end
+  end
+
+  describe "#fail_due_to_valiation!" do
+
+    let(:document) do
+      Band.new
+    end
+
+    it "raises the validation error" do
+      expect {
+        document.fail_due_to_validation!
+      }.to raise_error(Mongoid::Errors::Validations)
+    end
+  end
+
+  describe "#fail_due_to_callback!" do
+
+    let(:document) do
+      Band.new
+    end
+
+    it "raises the callback error" do
+      expect {
+        document.fail_due_to_callback!(:save!)
+      }.to raise_error(Mongoid::Errors::Callback)
+    end
+  end
+end

data/spec/mongoid/positional_spec.rb

@@ -0,0 +1,227 @@
+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",
+          "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.$.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.$.children.1.children.3.field" => "value",
+              "children.$.children.1.children.3.field" => "value",
+            },
+            "$pushAll" => {
+              "children.$.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",
+              "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
+
+    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.$.children.3.field" => "value",
+            "children.0.children.$.children.3.field" => "value",
+          },
+          "$pushAll" => {
+            "children.0.children.$.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.$.field" => "value",
+            "children.0.children.1.children.$.field" => "value",
+          },
+          "$pushAll" => {
+            "children.0.children.1.children.$.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