mongoid 6.4.8 → 7.0.0

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

@@ -1,101 +0,0 @@
-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
-          expect(home).to 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
-          expect(person).to 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
-          expect(post_one).to receive(:delete).never
-          expect(post_two).to receive(:delete).never
-          person.delete
-        end
-
-        it "deletes the first document" do
-          expect(post_one).to be_destroyed
-        end
-
-        it "deletes the second document" do
-          expect(post_two).to be_destroyed
-        end
-
-        it "unbinds the first document" do
-          expect(post_one.person).to be_nil
-        end
-
-        it "unbinds the second document" do
-          expect(post_two.person).to be_nil
-        end
-
-        it "removes the documents from the relation" do
-          expect(person.posts).to 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

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

@@ -1,47 +0,0 @@
-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
-        expect(person).to receive(:posts).and_return([ post ])
-      end
-
-      it "destroys all documents in the relation" do
-        expect(post).to receive(:destroy)
-        strategy.cascade
-      end
-    end
-
-    context "when no documents exist" do
-
-      before do
-        expect(person).to receive(:posts).and_return([])
-      end
-
-      it "does not destroy anything" do
-        expect(post).to receive(:destroy).never
-        strategy.cascade
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-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
-      expect(person).to receive(:posts).and_return(relation)
-    end
-
-    it "nullifies the relation" do
-      expect(relation).to receive(:nullify)
-      strategy.cascade
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-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
-          expect(person).to receive(:drugs).and_return([ ])
-        end
-
-        it "deletes the person" do
-          expect { strategy.cascade }.to_not raise_error
-        end
-      end
-
-      context "when person has drugs" do
-
-        before do
-          expect(person).to 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
-        expect(person).to receive(:drugs).and_return([])
-      end
-
-      it "doesn't delete anything" do
-        expect(drug).to receive(:delete).never
-        strategy.cascade
-      end
-    end
-  end
-end

data/spec/mongoid/relations/cascading_spec.rb

@@ -1,355 +0,0 @@
-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
-              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
-              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
-              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

data/spec/mongoid/relations/constraint_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Constraint do
-
-  describe "#convert" do
-
-    context "when the id's class stores object ids" do
-
-      before(:all) do
-        Person.field(
-          :_id,
-          type: BSON::ObjectId,
-          pre_processed: true,
-          default: ->{ BSON::ObjectId.new },
-          overwrite: true
-        )
-      end
-
-      let(:metadata) do
-        Mongoid::Relations::Metadata.new(
-          class_name: "Person",
-          name: :person,
-          inverse_class_name: "Post",
-          relation: Mongoid::Relations::Referenced::In
-        )
-      end
-
-      let(:constraint) do
-        described_class.new(metadata)
-      end
-
-      context "when provided an object id" do
-
-        let(:object) do
-          BSON::ObjectId.new
-        end
-
-        it "returns the object id" do
-          expect(constraint.convert(object)).to eq(object)
-        end
-      end
-
-      context "when provided a string" do
-
-        let(:object) do
-          BSON::ObjectId.new
-        end
-
-        it "returns an object id from the string" do
-          expect(constraint.convert(object.to_s)).to eq(object)
-        end
-      end
-    end
-
-    context "when the id's class does not store object ids" do
-
-      let(:metadata) do
-        Mongoid::Relations::Metadata.new(
-          class_name: "Account",
-          name: :account,
-          inverse_class_name: "Alert",
-          relation: Mongoid::Relations::Referenced::In
-        )
-      end
-
-      let(:constraint) do
-        described_class.new(metadata)
-      end
-
-      it "returns the object" do
-        expect(constraint.convert("testing")).to eq("testing")
-      end
-    end
-  end
-end