mongoid 3.1.4 → 3.1.5

data/spec/mongoid/relations/builders/referenced/one_spec.rb

@@ -0,0 +1,124 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Builders::Referenced::One do
+
+  let(:base) do
+    stub(new_record?: false)
+  end
+
+  describe "#build" do
+
+    let(:criteria) do
+      Post.where("person_id" => object)
+    end
+
+    let(:metadata) do
+      stub(
+        klass: Post,
+        name: :post,
+        foreign_key: "person_id",
+        criteria: criteria,
+        inverse_klass: Person
+      )
+    end
+
+    let(:builder) do
+      described_class.new(base, metadata, object)
+    end
+
+    context "when provided an id" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:object) do
+        object_id
+      end
+
+      let(:post) do
+        stub
+      end
+
+      before do
+        criteria.should_receive(:first).and_return(post)
+      end
+
+      let!(:documents) do
+        builder.build
+      end
+
+      it "sets the document" do
+        documents.should eq(post)
+      end
+    end
+
+    context "when provided a object" do
+
+      let(:object) do
+        Post.new
+      end
+
+      let(:document) do
+        builder.build
+      end
+
+      it "returns the object" do
+        document.should eq(object)
+      end
+    end
+  end
+
+  describe "#build" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when the document is not found" do
+
+      it "returns nil" do
+        person.game.should be_nil
+      end
+    end
+
+    context "when the document is persisted" do
+
+      before do
+        Mongoid.identity_map_enabled = true
+        person.save
+      end
+
+      after do
+        Mongoid.identity_map_enabled = false
+      end
+
+      let!(:game) do
+        Game.create(person_id: person.id)
+      end
+
+      it "returns the document" do
+        person.game.should eq(game)
+      end
+
+      it "pulls the document from the identity map" do
+        person.game.should equal(game)
+      end
+    end
+
+    context "when the document have a non standard pk" do
+
+      before do
+        person.save
+      end
+
+      let!(:cat) do
+        Cat.create(person_id: person.username)
+      end
+
+      it "returns the document" do
+        person.cat.should eq(cat)
+      end
+    end
+  end
+end

data/spec/mongoid/relations/builders_spec.rb

@@ -0,0 +1,226 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Builders do
+
+  describe "#build_#\{name}" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when providing no attributes" do
+
+      context "when the relation is an embeds one" do
+
+        let(:name) do
+          person.build_name
+        end
+
+        it "does not set a binding attribute" do
+          name[:binding].should be_nil
+        end
+      end
+
+      context "when the relation is a references one" do
+
+        let(:game) do
+          person.build_game
+        end
+
+        it "does not set a binding attribute" do
+          game[:binding].should be_nil
+        end
+      end
+
+      context "when the relation is a belongs to" do
+
+        context "when the inverse is a has many" do
+
+          let(:post) do
+            Post.new
+          end
+
+          let!(:person) do
+            post.build_person
+          end
+
+          it "builds the document" do
+            post.person.should eq(person)
+          end
+
+          it "sets the inverse" do
+            person.posts.should eq([ post ])
+          end
+
+          it "does not save the document" do
+            person.should_not be_persisted
+          end
+        end
+
+        context "when the inverse is a has one" do
+
+          let(:game) do
+            Game.new
+          end
+
+          let!(:person) do
+            game.build_person
+          end
+
+          it "builds the document" do
+            game.person.should eq(person)
+          end
+
+          it "sets the inverse" do
+            person.game.should eq(game)
+          end
+
+          it "does not save the document" do
+            person.should_not be_persisted
+          end
+        end
+      end
+    end
+  end
+
+  describe "#create_#\{name}" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when providing no attributes" do
+
+      context "when the relation is an embeds one" do
+
+        let(:name) do
+          person.create_name
+        end
+
+        it "does not set a binding attribute" do
+          name[:binding].should be_nil
+        end
+      end
+
+      context "when the relation is a references one" do
+
+        let(:game) do
+          person.create_game
+        end
+
+        it "does not set a binding attribute" do
+          game[:binding].should be_nil
+        end
+      end
+
+      context "when the relation is a belongs to" do
+
+        context "when the inverse is a has many" do
+
+          let(:post) do
+            Post.new
+          end
+
+          let!(:person) do
+            post.create_person
+          end
+
+          it "builds the document" do
+            post.person.should eq(person)
+          end
+
+          it "sets the inverse" do
+            person.posts.should eq([ post ])
+          end
+
+          it "saves the document" do
+            person.should be_persisted
+          end
+
+          it "saves the child" do
+            post.should be_persisted
+          end
+        end
+
+        context "when the inverse is a has one" do
+
+          let(:game) do
+            Game.new
+          end
+
+          let!(:person) do
+            game.create_person
+          end
+
+          it "builds the document" do
+            game.person.should eq(person)
+          end
+
+          it "sets the inverse" do
+            person.game.should eq(game)
+          end
+
+          it "saves the document" do
+            person.should be_persisted
+          end
+
+          it "saves the child" do
+            game.should be_persisted
+          end
+        end
+      end
+    end
+
+    context "when the parent is persisted" do
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when the relation is a has one" do
+
+        let!(:game_one) do
+          person.create_game(name: "Starcraft")
+        end
+
+        context "when a document already exists" do
+
+          let!(:game_two) do
+            person.create_game(name: "Skyrim")
+          end
+
+          it "replaces the existing document" do
+            person.game.should eq(game_two)
+          end
+
+          it "persists the change" do
+            person.game(true).should eq(game_two)
+          end
+
+          it "removes the old document from the database" do
+            Game.collection.find.count.should eq(1)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#build" do
+
+    context "with criteria applied" do
+
+      let(:person) do
+        Person.new
+      end
+
+      let(:services) do
+        person.services.asc(:sid)
+      end
+
+      subject { services.build }
+
+      it { should be_a_kind_of(Service) }
+      it { should_not be_persisted }
+    end
+  end
+end

data/spec/mongoid/relations/cascading/delete_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Cascading::Delete do
+
+  let(:person) do
+    Person.create
+  end
+
+  describe "#cascade" do
+
+    context "when cascading a has one" do
+
+      context "when the relation exists" do
+
+        let!(:home) do
+          person.create_home
+        end
+
+        before do
+          person.delete
+        end
+
+        it "deletes the relation" do
+          home.should be_destroyed
+        end
+
+        it "persists the deletion" do
+          expect {
+            home.reload
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+
+      context "when the relation does not exist" do
+
+        before do
+          person.delete
+        end
+
+        it "deletes the base document" do
+          person.should be_destroyed
+        end
+      end
+    end
+  end
+
+  context "when cascading a has many" do
+
+    context "when the relation has documents" do
+
+      let!(:post_one) do
+        person.posts.create(title: "one")
+      end
+
+      let!(:post_two) do
+        person.posts.create(title: "two")
+      end
+
+      context "when the documents are in memory" do
+
+        before do
+          post_one.should_receive(:delete).never
+          post_two.should_receive(:delete).never
+          person.delete
+        end
+
+        it "deletes the first document" do
+          post_one.should be_destroyed
+        end
+
+        it "deletes the second document" do
+          post_two.should be_destroyed
+        end
+
+        it "unbinds the first document" do
+          post_one.person.should be_nil
+        end
+
+        it "unbinds the second document" do
+          post_two.person.should be_nil
+        end
+
+        it "removes the documents from the relation" do
+          person.posts.should be_empty
+        end
+
+        it "persists the first deletion" do
+          expect {
+            post_one.reload
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+
+        it "persists the second deletion" do
+          expect {
+            post_two.reload
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+    end
+  end
+end