mongoid_rails4 4.0.0

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Cascading::Destroy do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:metadata) do
+    double(name: :posts)
+  end
+
+  let(:strategy) do
+    described_class.new(person, metadata)
+  end
+
+  describe "#cascade" do
+
+    let(:post) do
+      double
+    end
+
+    context "when the documents exist" do
+
+      before do
+        person.should_receive(:posts).and_return([ post ])
+      end
+
+      it "destroys all documents in the relation" do
+        post.should_receive(:destroy)
+        strategy.cascade
+      end
+    end
+
+    context "when no documents exist" do
+
+      before do
+        person.should_receive(:posts).and_return([])
+      end
+
+      it "does not destroy anything" do
+        post.should_receive(:destroy).never
+        strategy.cascade
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Cascading::Nullify do
+
+  let(:person) do
+    Person.new
+  end
+
+  describe "#cascade" do
+
+    let(:relation) do
+      double
+    end
+
+    let(:metadata) do
+      double(name: :posts)
+    end
+
+    let(:strategy) do
+      described_class.new(person, metadata)
+    end
+
+    before do
+      person.should_receive(:posts).and_return(relation)
+    end
+
+    it "nullifies the relation" do
+      relation.should_receive(:nullify)
+      strategy.cascade
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Mongoid::Relations::Cascading::Restrict do
+
+  before :each do
+    Person.has_many :drugs, validate: false, dependent: :restrict
+  end
+
+  after :each do
+    Person.cascades.delete("drugs")
+    Person.has_many :drugs, validate: false
+  end
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:metadata) do
+    double(name: :drugs)
+  end
+
+  let(:strategy) do
+    described_class.new(person, metadata)
+  end
+
+  describe "#cascade" do
+
+    let(:drug) do
+      double
+    end
+
+    context "when the document exists" do
+
+      context "when person has no drugs" do
+
+        before do
+          person.should_receive(:drugs).and_return([ ])
+        end
+
+        it "deletes the person" do
+          expect { strategy.cascade }.to_not raise_error(Mongoid::Errors::DeleteRestriction)
+        end
+      end
+
+      context "when person has drugs" do
+
+        before do
+          person.should_receive(:drugs).and_return([ drug ])
+        end
+
+        it "it raises an error" do
+          expect { strategy.cascade }.to raise_error(Mongoid::Errors::DeleteRestriction)
+        end
+      end
+    end
+
+    context "when no document exists" do
+      before do
+        person.should_receive(:drugs).and_return([])
+      end
+
+      it "doesn't delete anything" do
+        drug.should_receive(:delete).never
+        strategy.cascade
+      end
+    end
+  end
+end

data/spec/mongoid/relations/cascading_spec.rb

@@ -0,0 +1,355 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Cascading do
+
+  describe "#cascade!" do
+
+    let(:band) do
+      Band.new
+    end
+
+    context "when the metadata exists" do
+
+      context "when the metadata has no cascade strategy" do
+
+        before do
+          band.cascades.push("records")
+        end
+
+        after do
+          band.cascades.delete("records")
+        end
+
+        it "ignores the cascade" do
+          expect(band.cascade!).to eq([ "records" ])
+        end
+      end
+    end
+  end
+
+  describe ".cascade" do
+
+    let(:klass) do
+      Class.new.tap { |c| c.send(:include, Mongoid::Document) }
+    end
+
+    context "when the metadata doesnt exist" do
+
+      before do
+        klass.cascades.push("nothing")
+      end
+
+      it "does not raise an error" do
+        expect {
+          klass.new.cascade!
+        }.not_to raise_error
+      end
+    end
+
+    context "when a dependent option is provided" do
+
+      let(:metadata) do
+        Mongoid::Relations::Metadata.new(
+          name: :posts,
+          dependent: :destroy,
+          relation: Mongoid::Relations::Referenced::Many
+        )
+      end
+
+      let!(:cascaded) do
+        klass.cascade(metadata)
+      end
+
+      it "adds the action to the cascades" do
+        expect(klass.cascades).to include("posts")
+      end
+
+      it "returns self" do
+        expect(cascaded).to eq(klass)
+      end
+    end
+
+    context "when no dependent option is provided" do
+
+      let(:metadata) do
+        Mongoid::Relations::Metadata.new(
+          name: :posts,
+          relation: Mongoid::Relations::Referenced::Many
+        )
+      end
+
+      let!(:cascaded) do
+        klass.cascade(metadata)
+      end
+
+      it "does not add an action to the cascades" do
+        expect(klass.cascades).to_not include("posts")
+      end
+
+      it "returns self" do
+        expect(cascaded).to eq(klass)
+      end
+    end
+  end
+
+  [ :delete, :destroy ].each do |method|
+
+    describe "##{method}" do
+
+      context "when cascading removals" do
+
+        context "when dependent is delete" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let!(:post) do
+            person.posts.create(title: "Testing")
+          end
+
+          before do
+            person.send(method)
+          end
+
+          it "deletes the associated documents" do
+            expect {
+              Post.find(post.id)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context "when dependent is destroy" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let!(:game) do
+            person.create_game(name: "Pong")
+          end
+
+          before do
+            person.send(method)
+          end
+
+          it "destroys the associated documents" do
+            expect {
+              Game.find(game.id)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context "when dependent is nullify" do
+
+          context "when nullifying a references many" do
+
+            let(:movie) do
+              Movie.create(title: "Bladerunner")
+            end
+
+            let!(:rating) do
+              movie.ratings.create(value: 10)
+            end
+
+            let(:from_db) do
+              Rating.find(rating.id)
+            end
+
+            before do
+              movie.send(method)
+            end
+
+            it "removes the references to the removed document" do
+              expect(from_db.ratable_id).to be_nil
+            end
+          end
+
+          context "when nullifying a references one" do
+
+            context "when the relation exists" do
+
+              let(:book) do
+                Book.create(title: "Neuromancer")
+              end
+
+              let!(:rating) do
+                book.create_rating(value: 10)
+              end
+
+              let(:from_db) do
+                Rating.find(rating.id)
+              end
+
+              before do
+                book.send(method)
+              end
+
+              it "removes the references to the removed document" do
+                expect(from_db.ratable_id).to be_nil
+              end
+            end
+
+            context "when the relation is nil" do
+
+              let(:book) do
+                Book.create(title: "Neuromancer")
+              end
+
+              it "returns nil" do
+                expect(book.send(method)).to be_true
+              end
+            end
+          end
+
+          context "when nullifying a many to many" do
+
+            let(:person) do
+              Person.create
+            end
+
+            let!(:preference) do
+              person.preferences.create(name: "Setting")
+            end
+
+            let(:from_db) do
+              Preference.find(preference.id)
+            end
+
+            before do
+              person.send(method)
+            end
+
+            it "removes the references from the removed document" do
+              expect(person.preference_ids).to_not include(preference.id)
+            end
+
+            it "removes the references to the removed document" do
+              expect(from_db.person_ids).to_not include(person.id)
+            end
+          end
+        end
+
+        context "when dependent is restrict" do
+
+          context "when restricting a references many" do
+
+            before do
+              Person.has_many :drugs, dependent: :restrict
+            end
+
+            after do
+              Person.cascades.delete("drugs")
+              Person.has_many :drugs, validate: false
+            end
+
+            context "when the relation is empty" do
+
+              let(:person) do
+                Person.new drugs: []
+              end
+
+              it "raises no error" do
+                expect{ person.send(method) }.to_not raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+
+              it "deletes the parent" do
+                person.send(method)
+                expect(person).to be_destroyed
+              end
+            end
+
+            context "when the relation is not empty" do
+
+              let(:person) do
+                Person.new drugs: [ Drug.new ]
+              end
+
+              it "raises DeleteRestriction error" do
+                expect{ person.send(method) }.to raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+            end
+          end
+
+          context "when restricting a references one" do
+
+            before do
+              Person.has_one :account, dependent: :restrict
+            end
+
+            after do
+              Person.cascades.delete("account")
+              Person.has_one :account, validate: false
+            end
+
+            context "when the relation is empty" do
+
+              let(:person) do
+                Person.new account: nil
+              end
+
+              it "raises no error" do
+                expect{ person.send(method) }.to_not raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+
+              it "deletes the parent" do
+                person.send(method)
+                expect(person).to be_destroyed
+              end
+            end
+
+            context "when the relation is not empty" do
+
+              let(:person) do
+                Person.new account: Account.new(name: 'test')
+              end
+
+              it "raises DeleteRestriction error" do
+                expect { person.send(method) }.to raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+            end
+          end
+
+          context "when restricting a many to many" do
+
+            before do
+              Person.has_and_belongs_to_many :houses, dependent: :restrict
+            end
+
+            after do
+              Person.cascades.delete("houses")
+              Person.has_and_belongs_to_many :houses, validate: false
+            end
+
+            context "when the relation is empty" do
+
+              let(:person) do
+                Person.new houses: []
+              end
+
+              it "raises no error" do
+                expect{ person.send(method) }.to_not raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+
+              it "deletes the parent" do
+                person.send(method)
+                expect(person).to be_destroyed
+              end
+            end
+
+            context "when the relation is not empty" do
+
+              let(:person) do
+                Person.new houses: [House.new]
+              end
+
+              it "raises DeleteRestriction error" do
+                expect { person.send(method) }.to raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end