sepastian-mongoid-rails4 4.0.0.alpha

data/spec/mongoid/persistable/updatable_spec.rb

@@ -0,0 +1,558 @@
+require "spec_helper"
+
+describe Mongoid::Persistable::Updatable do
+
+  describe "#update_attribute" do
+
+    context "when the field is aliased" do
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when the setter is overridden" do
+
+        before do
+          person.update_attribute(:overridden_setter, "value")
+        end
+
+        it "updates the field" do
+          expect(person.overridden_setter).to eq("value")
+        end
+
+        it "clears the dirty attributes" do
+          expect(person).to_not be_changed
+        end
+
+        it "calls the overridden setter" do
+          expect(person.instance_variable_get(:@override_called)).to be_true
+        end
+
+        it "persists the changes" do
+          expect(person.reload.overridden_setter).to eq("value")
+        end
+      end
+
+      context "when setting via the field name" do
+
+        before do
+          person.update_attribute(:t, "testing")
+        end
+
+        it "updates the field" do
+          expect(person.t).to eq("testing")
+        end
+
+        it "persists the changes" do
+          expect(person.reload.t).to eq("testing")
+        end
+      end
+
+      context "when setting via the field alias" do
+
+        before do
+          person.update_attribute(:test, "testing")
+        end
+
+        it "updates the field" do
+          expect(person.t).to eq("testing")
+        end
+
+        it "persists the changes" do
+          expect(person.reload.t).to eq("testing")
+        end
+      end
+    end
+
+    context "when setting an array field" do
+
+      let(:person) do
+        Person.create(aliases: [])
+      end
+
+      before do
+        person.update_attribute(:aliases, person.aliases << "Bond")
+      end
+
+      it "sets the new value in the document" do
+        expect(person.aliases).to eq([ "Bond" ])
+      end
+
+      it "persists the changes" do
+        expect(person.reload.aliases).to eq([ "Bond" ])
+      end
+    end
+
+    context "when setting a boolean field" do
+
+      context "when the field is true" do
+
+        let(:person) do
+          Person.new(terms: true)
+        end
+
+        context "when setting to false" do
+
+          before do
+            person.update_attribute(:terms, false)
+          end
+
+          it "persists the document" do
+            expect(person).to be_persisted
+          end
+
+          it "changes the attribute value" do
+            expect(person.terms).to be_false
+          end
+
+          it "persists the changes" do
+            expect(person.reload.terms).to be_false
+          end
+        end
+      end
+    end
+
+    context "when provided a symbol attribute name" do
+
+      let(:post) do
+        Post.new
+      end
+
+      context "when the document is valid" do
+
+        before do
+          post.update_attribute(:title, "Testing")
+        end
+
+        it "sets the attribute" do
+          expect(post.title).to eq("Testing")
+        end
+
+        it "saves the document" do
+          expect(post).to be_persisted
+        end
+      end
+
+      context "when updating to the same value" do
+
+        before do
+          post.update_attribute(:title, "Testing")
+        end
+
+        it "returns true" do
+          expect(post.update_attribute(:title, "Testing")).to be_true
+        end
+      end
+
+      context "when the document is invalid" do
+
+        before do
+          post.update_attribute(:title, "$invalid")
+        end
+
+        it "sets the attribute" do
+          expect(post.title).to eq("$invalid")
+        end
+
+        it "saves the document" do
+          expect(post).to be_persisted
+        end
+      end
+
+      context "when the document has been destroyed" do
+
+        before do
+          post.delete
+        end
+
+        it "raises an error" do
+          expect {
+            post.update_attribute(:title, "something")
+          }.to raise_error
+        end
+      end
+    end
+
+    context "when provided a string attribute name" do
+
+      let(:post) do
+        Post.new
+      end
+
+      context "when the document is valid" do
+
+        before do
+          post.update_attribute("title", "Testing")
+        end
+
+        it "sets the attribute" do
+          expect(post.title).to eq("Testing")
+        end
+
+        it "saves the document" do
+          expect(post).to be_persisted
+        end
+      end
+
+      context "when the document is invalid" do
+
+        before do
+          post.update_attribute("title", "$invalid")
+        end
+
+        it "sets the attribute" do
+          expect(post.title).to eq("$invalid")
+        end
+
+        it "saves the document" do
+          expect(post).to be_persisted
+        end
+      end
+    end
+
+    context "when persisting a localized field" do
+
+      let!(:product) do
+        Product.create(description: "The bomb")
+      end
+
+      before do
+        ::I18n.locale = :de
+        product.update_attribute(:description, "Die Bombe")
+      end
+
+      after do
+        ::I18n.locale = :en
+      end
+
+      let(:attributes) do
+        product.attributes["description"]
+      end
+
+      it "persists the en locale" do
+        expect(attributes["en"]).to eq("The bomb")
+      end
+
+      it "persists the de locale" do
+        expect(attributes["de"]).to eq("Die Bombe")
+      end
+    end
+
+    context "when updating a deeply embedded document" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      let!(:address) do
+        person.addresses.create(street: "Winterfeldtstr")
+      end
+
+      let!(:location) do
+        address.locations.create(name: "work")
+      end
+
+      let(:from_db) do
+        Person.last.addresses.last.locations.last
+      end
+
+      before do
+        from_db.update_attribute(:name, "home")
+      end
+
+      it "updates the attribute" do
+        expect(from_db.name).to eq("home")
+      end
+
+      it "persists the changes" do
+        expect(from_db.reload.name).to eq("home")
+      end
+    end
+  end
+
+  [:update_attributes, :update].each do |method|
+
+    describe "##{method}" do
+
+      context "when saving with a hash field with invalid keys" do
+
+        let(:person) do
+          Person.create
+        end
+
+        it "raises an error" do
+          expect {
+            person.update_attributes(map: { "bad.key" => "value" })
+          }.to raise_error(Moped::Errors::OperationFailure)
+        end
+      end
+
+      context "when validation passes" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let!(:saved) do
+          person.update_attributes(pets: false)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "returns true" do
+          expect(saved).to be_true
+        end
+
+        it "saves the attributes" do
+          expect(from_db.pets).to be_false
+        end
+      end
+
+      context "when the document has been destroyed" do
+
+        let(:person) do
+          Person.create
+        end
+
+        it "raises an error" do
+          expect {
+            person.with(safe: true).send(method, map: { "bad.key" => "value" })
+          }.to raise_error(Moped::Errors::OperationFailure)
+        end
+      end
+
+      context "when validation passes" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let!(:saved) do
+          person.send(method, pets: false)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "returns true" do
+          expect(saved).to be_true
+        end
+
+        it "saves the attributes" do
+          expect(from_db.pets).to be_false
+        end
+      end
+
+      context "when the document has been destroyed" do
+
+        let!(:person) do
+          Person.create
+        end
+
+        before do
+          person.delete
+        end
+
+        it "raises an error" do
+          expect {
+            person.send(method, title: "something")
+          }.to raise_error
+        end
+      end
+
+      context "when updating through a one-to-one relation" do
+
+        let(:person) do
+          Person.create!
+        end
+
+        let(:game) do
+          Game.create(person: person)
+        end
+
+        before do
+          person.send(method, ssn: "444-44-4444")
+          game.person.send(method, ssn: "555-66-7777")
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "saves the attributes" do
+          expect(person.ssn).to eq("555-66-7777")
+        end
+      end
+
+      context "on a new record" do
+
+        let(:person) do
+          Person.new
+        end
+
+        before do
+          person.send(method, pets: false, title: nil)
+        end
+
+        it "saves the new record" do
+          expect(Person.find(person.id)).to_not be_nil
+        end
+      end
+
+      context "when passing in a relation" do
+
+        context "when providing an embedded child" do
+
+          let!(:person) do
+            Person.create
+          end
+
+          let!(:name) do
+            person.create_name(first_name: "test", last_name: "user")
+          end
+
+          let(:new_name) do
+            Name.new(first_name: "Rupert", last_name: "Parkes")
+          end
+
+          before do
+            person.send(method, name: new_name)
+          end
+
+          it "updates the embedded document" do
+            expect(person.name).to eq(new_name)
+          end
+
+          it "persists the changes" do
+            expect(person.reload.name).to eq(new_name)
+          end
+        end
+
+        context "when providing a parent to a referenced in" do
+
+          let!(:person) do
+            Person.create
+          end
+
+          let!(:post) do
+            Post.create(title: "Testing")
+          end
+
+          context "when the relation has not yet been touched" do
+
+            before do
+              post.send(method, person: person)
+            end
+
+            it "sets the instance of the relation" do
+              expect(person.posts).to eq([ post ])
+            end
+
+            it "sets properly through method_missing" do
+              expect(person.posts.to_a).to eq([ post ])
+            end
+
+            it "persists the reference" do
+              expect(person.posts(true)).to eq([ post ])
+            end
+          end
+
+          context "when the relation has been touched" do
+
+            before do
+              person.posts
+              post.send(method, person: person)
+            end
+
+            it "sets the instance of the relation" do
+              expect(person.posts).to eq([ post ])
+            end
+
+            it "sets properly through method_missing" do
+              expect(person.posts.to_a).to eq([ post ])
+            end
+
+            it "persists the reference" do
+              expect(person.posts(true)).to eq([ post ])
+            end
+          end
+        end
+      end
+
+      context "when in a deeply nested hierarchy" do
+
+        let!(:person) do
+          Person.new(title: "The Boss")
+        end
+
+        let!(:phone_number) do
+          Phone.new(number: "123-456-7890")
+        end
+
+        let!(:country_code) do
+          CountryCode.new(code: 1)
+        end
+
+        before do
+          phone_number.country_code = country_code
+          person.phone_numbers << phone_number
+          person.save
+        end
+
+        it "sets the first level document" do
+          expect(person.phone_numbers.first).to eq(phone_number)
+        end
+
+        it "sets the second level document" do
+          expect(person.phone_numbers.first.country_code).to eq(country_code)
+        end
+
+        context "when updating the first level document" do
+
+          let(:phone) do
+            person.phone_numbers.first
+          end
+
+          before do
+            phone.number = "098-765-4321"
+            phone.send(method, number: "098-765-4321")
+          end
+
+          it "sets the new attributes" do
+            expect(phone.number).to eq("098-765-4321")
+          end
+
+          context "when reloading the root" do
+
+            let(:reloaded) do
+              person.reload
+            end
+
+            it "saves the new attributes" do
+              expect(reloaded.phone_numbers.first.number).to eq("098-765-4321")
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#update!" do
+
+    context "when a callback returns false" do
+
+      let(:oscar) do
+        Oscar.new
+      end
+
+      it "raises a callback error" do
+        expect {
+          oscar.update!(title: "The Grouch")
+        }.to raise_error(Mongoid::Errors::Callback)
+      end
+    end
+  end
+end

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.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.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