mongoid 5.4.1 → 7.4.0

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

data/spec/mongoid/relations/conversions_spec.rb

@@ -1,128 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Conversions do
-
-  describe ".flag" do
-
-    context "when the inverse uses object ids" do
-
-      let(:metadata) do
-        Person.relations["game"]
-      end
-
-      let(:object) do
-        BSON::ObjectId.new
-      end
-
-      let(:flagged) do
-        described_class.flag(object, metadata)
-      end
-
-      it "returns the object" do
-        expect(flagged).to eq(object)
-      end
-    end
-
-    context "when the inverse uses string ids" do
-
-      before do
-        Person.field(
-          :_id,
-          type: String,
-          pre_processed: true,
-          overwrite: true,
-          default: ->{ BSON::ObjectId.new.to_s }
-        )
-      end
-
-      after do
-        Person.field(
-          :_id,
-          type: BSON::ObjectId,
-          pre_processed: true,
-          overwrite: true,
-          default: ->{ BSON::ObjectId.new }
-        )
-      end
-
-      let(:metadata) do
-        Person.relations["game"]
-      end
-
-      context "when provided an object id" do
-
-        let(:object) do
-          BSON::ObjectId.new
-        end
-
-        let(:flagged) do
-          described_class.flag(object, metadata)
-        end
-
-        it "returns the object id" do
-          expect(flagged).to eq(object)
-        end
-      end
-
-      context "when provided a string" do
-
-        let(:object) do
-          BSON::ObjectId.new.to_s
-        end
-
-        let(:flagged) do
-          described_class.flag(object, metadata)
-        end
-
-        it "returns the string" do
-          expect(flagged).to eq(object)
-        end
-
-        it "marks the string as unconvertable" do
-          expect(flagged).to be_unconvertable_to_bson
-        end
-      end
-    end
-
-    context "when the inverse uses integer ids" do
-
-      let(:metadata) do
-        Jar.relations["cookies"]
-      end
-
-      context "when provided an object id" do
-
-        let(:object) do
-          BSON::ObjectId.new
-        end
-
-        let(:flagged) do
-          described_class.flag(object, metadata)
-        end
-
-        it "returns the object id" do
-          expect(flagged).to eq(object)
-        end
-      end
-
-      context "when provided an integer" do
-
-        let(:object) do
-          15
-        end
-
-        let(:flagged) do
-          described_class.flag(object, metadata)
-        end
-
-        it "returns the integer" do
-          expect(flagged).to eq(15)
-        end
-
-        it "marks the integer as unconvertable" do
-          expect(flagged).to be_unconvertable_to_bson
-        end
-      end
-    end
-  end
-end