mongoid_rails4 4.0.0

data/spec/mongoid/criteria/inspectable_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Inspectable do
+
+  describe "#inspect" do
+
+    let(:criteria) do
+      Person.where(:age.gt => 10, title: "Sir")
+    end
+
+    it "includes the selector" do
+      expect(criteria.inspect).to include("selector")
+    end
+
+    it "includes the options" do
+      expect(criteria.inspect).to include("options")
+    end
+
+    it "includes the class" do
+      expect(criteria.inspect).to include("class")
+    end
+
+    it "includes the embedded flag" do
+      expect(criteria.inspect).to include("embedded")
+    end
+  end
+end

data/spec/mongoid/criteria/marshalable_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Marshalable do
+
+  describe "Marshal.dump" do
+
+    let(:criteria) do
+      Band.where(name: "Depeche Mode")
+    end
+
+    it "does not error" do
+      expect {
+        Marshal.dump(criteria)
+      }.not_to raise_error
+    end
+  end
+
+  describe "Marshal.load" do
+
+    let(:criteria) do
+      Band.where(name: "Depeche Mode")
+    end
+
+    it "loads the proper attributes" do
+      expect(Marshal.load(Marshal.dump(criteria))).to eq(criteria)
+    end
+  end
+end

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -0,0 +1,1063 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Modifiable do
+
+  describe "#create" do
+
+    let(:criteria) do
+      Band.where(name: "Depeche Mode")
+    end
+
+    context "when provided valid attributes" do
+      let(:band) do
+        criteria.create(genres: [ "electro" ])
+      end
+
+      it "returns the created document" do
+        expect(band).to be_persisted
+      end
+
+      it "sets the criteria attributes" do
+        expect(band.name).to eq("Depeche Mode")
+      end
+
+      it "sets the attributes passed to build" do
+        expect(band.genres).to eq([ "electro" ])
+      end
+    end
+
+    context "when provided a block" do
+
+      context "when provided valid attributes & using block" do
+
+        let(:band) do
+          criteria.create do |c|
+            c.genres = [ "electro" ]
+          end
+        end
+
+        it "returns the created document" do
+          expect(band).to be_persisted
+        end
+
+        it "sets the criteria attributes" do
+          expect(band.name).to eq("Depeche Mode")
+        end
+
+        it "sets the attributes passed to build" do
+          expect(band.genres).to eq([ "electro" ])
+        end
+      end
+    end
+  end
+
+  describe "#create!" do
+
+    let(:criteria) do
+      Account.where(number: "11123213")
+    end
+
+    context "when provided invalid attributes" do
+
+      it "raises an error" do
+        expect {
+          criteria.create!
+        }.to raise_error(Mongoid::Errors::Validations)
+      end
+    end
+  end
+
+  [ :delete, :delete_all, :destroy, :destroy_all ].each do |method|
+
+    describe "##{method}" do
+
+      let(:name) do
+        Name.new(first_name: "Durran")
+      end
+
+      let(:address_one) do
+        Address.new(street: "Forsterstr")
+      end
+
+      let(:address_two) do
+        Address.new(street: "Hobrechtstr")
+      end
+
+      before do
+        Person.create(title: "Madam")
+        2.times do |n|
+          Person.create(
+            title: "Sir",
+            name: name,
+            addresses: [ address_one, address_two ]
+          )
+        end
+      end
+
+      context "when removing root documents" do
+
+        let(:criteria) do
+          Person.where(title: "Sir", :age.gt => 5)
+        end
+
+        let!(:removed) do
+          criteria.send(method)
+        end
+
+        it "deletes the removes the documents from the database" do
+          expect(Person.count).to eq(1)
+        end
+
+        it "returns the number removed" do
+          expect(removed).to eq(2)
+        end
+      end
+
+      context "when removing embedded documents" do
+
+        context "when removing a single document" do
+
+          let(:person) do
+            Person.where(title: "Sir").first
+          end
+
+          let(:criteria) do
+            person.addresses.where(street: "Forsterstr")
+          end
+
+          let!(:removed) do
+            criteria.send(method)
+          end
+
+          it "deletes the removes the documents from the database" do
+            expect(person.addresses.count).to eq(1)
+          end
+
+          it "returns the number removed" do
+            expect(removed).to eq(1)
+          end
+        end
+
+        context "when removing multiple documents" do
+
+          let(:person) do
+            Person.where(title: "Sir").first
+          end
+
+          let(:criteria) do
+            person.addresses.where(city: nil)
+          end
+
+          let!(:removed) do
+            criteria.send(method)
+          end
+
+          it "deletes the removes the documents from the database" do
+            expect(person.addresses.count).to eq(0)
+          end
+
+          it "returns the number removed" do
+            expect(removed).to eq(2)
+          end
+        end
+      end
+    end
+  end
+
+  describe ".find_or_create_by" do
+
+    context "when the document is found" do
+
+      context "when providing an attribute" do
+
+        let!(:person) do
+          Person.create(title: "Senior")
+        end
+
+        it "returns the document" do
+          expect(Person.find_or_create_by(title: "Senior")).to eq(person)
+        end
+      end
+
+      context "when providing a document" do
+
+        context "with an owner with a BSON identity type" do
+
+          let!(:person) do
+            Person.create
+          end
+
+          let!(:game) do
+            Game.create(person: person)
+          end
+
+          context "when providing the object directly" do
+
+            let(:from_db) do
+              Game.find_or_create_by(person: person)
+            end
+
+            it "returns the document" do
+              expect(from_db).to eq(game)
+            end
+          end
+
+          context "when providing the proxy relation" do
+
+            let(:from_db) do
+              Game.find_or_create_by(person: game.person)
+            end
+
+            it "returns the document" do
+              expect(from_db).to eq(game)
+            end
+          end
+        end
+
+        context "with an owner with an Integer identity type" do
+
+          let!(:jar) do
+            Jar.create
+          end
+
+          let!(:cookie) do
+            Cookie.create(jar: jar)
+          end
+
+          let(:from_db) do
+            Cookie.find_or_create_by(jar: jar)
+          end
+
+          it "returns the document" do
+            expect(from_db).to eq(cookie)
+          end
+        end
+      end
+    end
+
+    context "when the document is not found" do
+
+      context "when providing a document" do
+
+        let!(:person) do
+          Person.create
+        end
+
+        let!(:game) do
+          Game.create
+        end
+
+        let(:from_db) do
+          Game.find_or_create_by(person: person)
+        end
+
+        it "returns the new document" do
+          expect(from_db.person).to eq(person)
+        end
+
+        it "does not return an existing false document" do
+          expect(from_db).to_not eq(game)
+        end
+      end
+
+      context "when not providing a block" do
+
+        let!(:person) do
+          Person.find_or_create_by(title: "Senorita")
+        end
+
+        it "creates a persisted document" do
+          expect(person).to be_persisted
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("Senorita")
+        end
+      end
+
+      context "when providing a block" do
+
+        let!(:person) do
+          Person.find_or_create_by(title: "Senorita") do |person|
+            person.pets = true
+          end
+        end
+
+        it "creates a persisted document" do
+          expect(person).to be_persisted
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("Senorita")
+        end
+
+        it "calls the block" do
+          expect(person.pets).to be_true
+        end
+      end
+    end
+  end
+
+  describe ".find_or_initialize_by" do
+
+    context "when the document is found" do
+
+      let!(:person) do
+        Person.create(title: "Senior")
+      end
+
+      it "returns the document" do
+        expect(Person.find_or_initialize_by(title: "Senior")).to eq(person)
+      end
+    end
+
+    context "when the document is not found" do
+
+      context "when not providing a block" do
+
+        let!(:person) do
+          Person.find_or_initialize_by(title: "Senorita")
+        end
+
+        it "creates a new document" do
+          expect(person).to be_new_record
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("Senorita")
+        end
+      end
+
+      context "when providing a block" do
+
+        let!(:person) do
+          Person.find_or_initialize_by(title: "Senorita") do |person|
+            person.pets = true
+          end
+        end
+
+        it "creates a new document" do
+          expect(person).to be_new_record
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("Senorita")
+        end
+
+        it "calls the block" do
+          expect(person.pets).to be_true
+        end
+      end
+    end
+  end
+
+  describe "first_or_create" do
+
+    let!(:band) do
+      Band.create(name: "Depeche Mode")
+    end
+
+    context "when the document is found" do
+
+      let(:found) do
+        Band.where(name: "Depeche Mode").first_or_create
+      end
+
+      it "returns the document" do
+        expect(found).to eq(band)
+      end
+    end
+
+    context "when the document is not found" do
+
+      context "when attributes are provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_create(origin: "Essex")
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a persisted document" do
+          expect(document).to be_persisted
+        end
+
+        it "sets the additional attributes" do
+          expect(document.origin).to eq("Essex")
+        end
+      end
+
+      context "when attributes are not provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_create
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a persisted document" do
+          expect(document).to be_persisted
+        end
+      end
+
+      context "when a block is provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_create do |doc|
+            doc.active = false
+          end
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a persisted document" do
+          expect(document).to be_persisted
+        end
+
+        it "yields to the block" do
+          expect(document.active).to be_false
+        end
+      end
+
+      context "when the criteria is complex" do
+
+        context "when the document is not found" do
+
+          let(:document) do
+            Band.in(name: [ "New Order" ]).first_or_create(active: false)
+          end
+
+          it "returns a new document" do
+            expect(document.active).to be_false
+          end
+
+          it "returns a persisted document" do
+            expect(document).to be_persisted
+          end
+        end
+      end
+    end
+  end
+
+  describe "first_or_create!" do
+
+    context "when validation fails on the new document" do
+
+      it "raises an error" do
+        expect {
+          Account.where(number: "12345").first_or_create!
+        }.to raise_error(Mongoid::Errors::Validations)
+      end
+    end
+
+    context "when passing a block" do
+
+      let(:account) do
+        Account.where(number: "12345").first_or_create! do |account|
+          account.name = "testing"
+        end
+      end
+
+      it "passes the block to the create call" do
+        expect(account.name).to eq("testing")
+      end
+
+      it "persists the new document" do
+        expect(account).to be_persisted
+      end
+    end
+
+    context "when the document is found" do
+
+      let!(:band) do
+        Band.with(safe: true).create!(name: "Depeche Mode")
+      end
+
+      let(:found) do
+        Band.where(name: "Depeche Mode").first_or_create!
+      end
+
+      it "returns the document" do
+        expect(found).to eq(band)
+      end
+    end
+
+    context "when the document is not found" do
+
+      let!(:band) do
+        Band.with(safe: true).create!(name: "Depeche Mode")
+      end
+
+      context "when attributes are provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_create!(origin: "Essex")
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a persisted document" do
+          expect(document).to be_persisted
+        end
+
+        it "sets the additional attributes" do
+          expect(document.origin).to eq("Essex")
+        end
+      end
+
+      context "when attributes are not provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_create!
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a persisted document" do
+          expect(document).to be_persisted
+        end
+      end
+
+      context "when a block is provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_create! do |doc|
+            doc.active = false
+          end
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a persisted document" do
+          expect(document).to be_persisted
+        end
+
+        it "yields to the block" do
+          expect(document.active).to be_false
+        end
+      end
+
+      context "when the criteria is complex" do
+
+        context "when the document is not found" do
+
+          let(:document) do
+            Band.in(name: [ "New Order" ]).first_or_create!(active: false)
+          end
+
+          it "returns a new document" do
+            expect(document.active).to be_false
+          end
+
+          it "returns a persisted document" do
+            expect(document).to be_persisted
+          end
+        end
+      end
+    end
+  end
+
+  describe "first_or_initialize" do
+
+    let!(:band) do
+      Band.create(name: "Depeche Mode")
+    end
+
+    context "when the document is found" do
+
+      let(:found) do
+        Band.where(name: "Depeche Mode").first_or_initialize
+      end
+
+      it "returns the document" do
+        expect(found).to eq(band)
+      end
+    end
+
+    context "when the document is not found" do
+
+      context "when attributes are provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_initialize(origin: "Essex")
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a non persisted document" do
+          expect(document).to_not be_persisted
+        end
+
+        it "sets the additional attributes" do
+          expect(document.origin).to eq("Essex")
+        end
+      end
+
+      context "when attributes are not provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_initialize
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a non persisted document" do
+          expect(document).to_not be_persisted
+        end
+      end
+
+      context "when a block is provided" do
+
+        let(:document) do
+          Band.where(name: "Tool").first_or_initialize do |doc|
+            doc.active = false
+          end
+        end
+
+        it "returns a new document" do
+          expect(document.name).to eq("Tool")
+        end
+
+        it "returns a non persisted document" do
+          expect(document).to_not be_persisted
+        end
+
+        it "yields to the block" do
+          expect(document.active).to be_false
+        end
+      end
+
+      context "when the criteria is complex" do
+
+        context "when the document is not found" do
+
+          let(:document) do
+            Band.in(name: [ "New Order" ]).first_or_initialize(active: false)
+          end
+
+          it "returns a new document" do
+            expect(document.active).to be_false
+          end
+
+          it "returns a non persisted document" do
+            expect(document).to_not be_persisted
+          end
+        end
+      end
+    end
+  end
+
+  describe "#update" do
+
+    let!(:person) do
+      Person.create!(title: "Sir")
+    end
+
+    let!(:address_one) do
+      person.addresses.create(street: "Oranienstr")
+    end
+
+    let!(:address_two) do
+      person.addresses.create(street: "Wienerstr")
+    end
+
+    context "when updating the root document" do
+
+      context "when updating with a criteria" do
+
+        before do
+          Person.where(title: "Sir").update(title: "Madam")
+        end
+
+        it "updates all the matching documents" do
+          expect(person.reload.title).to eq("Madam")
+        end
+      end
+
+      context "when updating all directly" do
+
+        before do
+          Person.update(title: "Madam")
+        end
+
+        it "updates all the matching documents" do
+          expect(person.reload.title).to eq("Madam")
+        end
+      end
+    end
+
+    context "when updating an embedded document" do
+
+      before do
+        Person.where(title: "Sir").update(
+          "addresses.0.city" => "Berlin"
+        )
+      end
+
+      let!(:from_db) do
+        Person.first
+      end
+
+      it "updates all the matching documents" do
+        expect(from_db.addresses.first.city).to eq("Berlin")
+      end
+
+      it "does not update non matching documents" do
+        expect(from_db.addresses.last.city).to be_nil
+      end
+    end
+
+    context "when updating a relation" do
+
+      context "when the relation is an embeds many" do
+
+        let(:from_db) do
+          Person.first
+        end
+
+        context "when updating the relation directly" do
+
+          before do
+            person.addresses.update(city: "London")
+          end
+
+          it "updates the first document" do
+            expect(from_db.addresses.first.city).to eq("London")
+          end
+
+          it "does not update the last document" do
+            expect(from_db.addresses.last.city).to be_nil
+          end
+        end
+
+        context "when updating the relation through a criteria" do
+
+          before do
+            person.addresses.where(street: "Oranienstr").update(city: "Berlin")
+          end
+
+          it "updates the matching documents" do
+            expect(from_db.addresses.first.city).to eq("Berlin")
+          end
+
+          it "does not update non matching documents" do
+            expect(from_db.addresses.last.city).to be_nil
+          end
+        end
+      end
+
+      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")
+        end
+
+        context "when updating the relation directly" do
+
+          before do
+            person.posts.update(title: "London")
+          end
+
+          let!(:from_db) do
+            Person.first
+          end
+
+          it "updates the first document" do
+            expect(from_db.posts.first.title).to eq("London")
+          end
+
+          it "does not update the last document" do
+            expect(from_db.posts.last.title).to eq("Second")
+          end
+        end
+
+        context "when updating the relation through a criteria" do
+
+          before do
+            person.posts.where(title: "First").update(title: "Berlin")
+          end
+
+          let!(:from_db) do
+            Person.first
+          end
+
+          it "updates the matching documents" do
+            expect(from_db.posts.where(title: "Berlin").count).to eq(1)
+          end
+
+          it "does not update non matching documents" do
+            expect(from_db.posts.where(title: "Second").count).to eq(1)
+          end
+        end
+      end
+
+      context "when the relation is a references many to many" do
+
+        let(:from_db) do
+          Person.first
+        end
+
+        let!(:preference_one) do
+          person.preferences.create(name: "First")
+        end
+
+        let!(:preference_two) do
+          person.preferences.create(name: "Second")
+        end
+
+        context "when updating the relation directly" do
+
+          before do
+            person.preferences.update(name: "London")
+          end
+
+          it "updates the first document" do
+            expect(from_db.preferences.first.name).to eq("London")
+          end
+
+          it "does not update the last document" do
+            expect(from_db.preferences.last.name).to eq("Second")
+          end
+        end
+
+        context "when updating the relation through a criteria" do
+
+          before do
+            person.preferences.where(name: "First").update(name: "Berlin")
+          end
+
+          it "updates the matching documents" do
+            expect(from_db.preferences.first.name).to eq("Berlin")
+          end
+
+          it "does not update non matching documents" do
+            expect(from_db.preferences.last.name).to eq("Second")
+          end
+        end
+      end
+    end
+  end
+
+  describe "#update_all" do
+
+    let!(:person) do
+      Person.create(title: "Sir")
+    end
+
+    let!(:address_one) do
+      person.addresses.create(street: "Oranienstr")
+    end
+
+    let!(:address_two) do
+      person.addresses.create(street: "Wienerstr")
+    end
+
+    context "when updating the root document" do
+
+      context "when updating with a criteria" do
+
+        let(:from_db) do
+          Person.first
+        end
+
+        before do
+          Person.where(title: "Sir").update_all(title: "Madam")
+        end
+
+        it "updates all the matching documents" do
+          expect(from_db.title).to eq("Madam")
+        end
+      end
+
+      context "when updating all directly" do
+
+        let(:from_db) do
+          Person.first
+        end
+
+        before do
+          Person.update_all(title: "Madam")
+        end
+
+        it "updates all the matching documents" do
+          expect(from_db.title).to eq("Madam")
+        end
+      end
+    end
+
+    context "when updating an embedded document" do
+
+      before do
+        Person.where(title: "Sir").update_all(
+          "addresses.0.city" => "Berlin"
+        )
+      end
+
+      let!(:from_db) do
+        Person.first
+      end
+
+      it "updates all the matching documents" do
+        expect(from_db.addresses.first.city).to eq("Berlin")
+      end
+
+      it "does not update non matching documents" do
+        expect(from_db.addresses.last.city).to be_nil
+      end
+    end
+
+    context "when updating a relation" do
+
+      context "when the relation is an embeds many" do
+
+        let(:from_db) do
+          Person.first
+        end
+
+        context "when updating the relation directly" do
+
+          before do
+            person.addresses.update_all(city: "London")
+          end
+
+          it "updates the first document" do
+            expect(from_db.addresses.first.city).to eq("London")
+          end
+
+          it "updates the last document" do
+            expect(from_db.addresses.last.city).to eq("London")
+          end
+        end
+
+        context "when updating the relation through a criteria" do
+
+          before do
+            person.addresses.where(street: "Oranienstr").update_all(city: "Berlin")
+          end
+
+          it "updates the matching documents" do
+            expect(from_db.addresses.first.city).to eq("Berlin")
+          end
+
+          it "does not update non matching documents" do
+            expect(from_db.addresses.last.city).to be_nil
+          end
+        end
+      end
+
+      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")
+        end
+
+        context "when updating the relation directly" do
+
+          before do
+            person.posts.update_all(title: "London")
+          end
+
+          let!(:from_db) do
+            Person.first
+          end
+
+          it "updates the first document" do
+            expect(from_db.posts.first.title).to eq("London")
+          end
+
+          it "updates the last document" do
+            expect(from_db.posts.last.title).to eq("London")
+          end
+        end
+
+        context "when updating the relation through a criteria" do
+
+          before do
+            person.posts.where(title: "First").update_all(title: "Berlin")
+          end
+
+          let!(:from_db) do
+            Person.first
+          end
+
+          it "updates the matching documents" do
+            expect(from_db.posts.where(title: "Berlin").count).to eq(1)
+          end
+
+          it "does not update non matching documents" do
+            expect(from_db.posts.where(title: "Second").count).to eq(1)
+          end
+        end
+      end
+
+      context "when the relation is a references many to many" do
+
+        let(:from_db) do
+          Person.first
+        end
+
+        let!(:preference_one) do
+          person.preferences.create(name: "First")
+        end
+
+        let!(:preference_two) do
+          person.preferences.create(name: "Second")
+        end
+
+        context "when updating the relation directly" do
+
+          before do
+            person.preferences.update_all(name: "London")
+          end
+
+          it "updates the first document" do
+            expect(from_db.preferences.first.name).to eq("London")
+          end
+
+          it "updates the last document" do
+            expect(from_db.preferences.last.name).to eq("London")
+          end
+        end
+
+        context "when updating the relation through a criteria" do
+
+          before do
+            person.preferences.where(name: "First").update_all(name: "Berlin")
+          end
+
+          it "updates the matching documents" do
+            expect(from_db.preferences.first.name).to eq("Berlin")
+          end
+
+          it "does not update non matching documents" do
+            expect(from_db.preferences.last.name).to eq("Second")
+          end
+        end
+      end
+    end
+  end
+end