mongoid 5.4.0 → 6.4.8

data/spec/mongoid/relations/macros_spec.rb

@@ -15,12 +15,50 @@ describe Mongoid::Relations::Macros do
     klass._validators.clear
   end
 
+  after do
+    klass.relations.clear
+    klass.validators.clear
+  end
+
+  describe 'Model loading' do
+
+    let(:model_associations) do
+      class TestModel
+        include Mongoid::Document
+        field :associations
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :TestModel)
+    end
+
+    it 'prohibits the use of :associations as an attribute' do
+      expect {
+        model_associations
+      }.to raise_exception(Mongoid::Errors::InvalidField)
+    end
+  end
+
   describe ".embedded_in" do
 
     it "defines the macro" do
       expect(klass).to respond_to(:embedded_in)
     end
 
+    context 'when the relation name is invalid' do
+
+      let(:relation) do
+        klass.embedded_in(:fields)
+      end
+
+      it 'raises an InvalidRelation exception' do
+        expect {
+          relation
+        }.to raise_exception(Mongoid::Errors::InvalidRelation)
+      end
+    end
+
     context "when defining the relation" do
 
       before do
@@ -74,6 +112,19 @@ describe Mongoid::Relations::Macros do
 
     context "when defining the relation" do
 
+      context 'when the relation name is invalid' do
+
+        let(:relation) do
+          klass.embeds_many(:fields)
+        end
+
+        it 'raises an InvalidRelation exception' do
+          expect {
+            relation
+          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+        end
+      end
+
       before do
         klass.embeds_many(:addresses)
       end
@@ -132,8 +183,8 @@ describe Mongoid::Relations::Macros do
         expect(metadata.order).to_not be_nil
       end
 
-      it "returns Origin::Key" do
-        expect(metadata.order).to be_kind_of(Origin::Key)
+      it "returns Mongoid::Criteria::Queryable::Key" do
+        expect(metadata.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
       end
     end
 
@@ -157,6 +208,19 @@ describe Mongoid::Relations::Macros do
 
     context "when defining the relation" do
 
+      context 'when the relation name is invalid' do
+
+        let(:relation) do
+          klass.embeds_one(:fields)
+        end
+
+        it 'raises an InvalidRelation exception' do
+          expect {
+            relation
+          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+        end
+      end
+
       before do
         klass.embeds_one(:name)
       end
@@ -223,8 +287,300 @@ describe Mongoid::Relations::Macros do
 
   describe ".belongs_to" do
 
+    let(:_class) do
+      class RelationsTestClass
+        include Mongoid::Document
+      end
+    end
+
+    let(:conf) do
+      CONFIG.merge(options: { belongs_to_required_by_default: default_require })
+    end
+
+    let(:relation) do
+      _class.new
+    end
+
+    let(:relation_options) { {} }
+
+    let(:default_require) { Mongoid.belongs_to_required_by_default }
+
+    before do
+      Mongoid.configure do |config|
+        config.load_configuration(conf)
+      end
+      _class.belongs_to(:person, relation_options)
+    end
+
+    after do
+      Object.send(:remove_const, _class.name)
+    end
+
+    after(:all) do
+      Mongoid.configure do |config|
+        config.load_configuration(CONFIG)
+      end
+    end
+
     it "defines the macro" do
-      expect(klass).to respond_to(:belongs_to)
+      expect(_class).to respond_to(:belongs_to)
+    end
+
+    context 'when the relation has options' do
+
+      context 'when the relation has the option :required' do
+
+        context 'when the relation does not have the :optional option' do
+
+          context 'when :required is true' do
+
+            let(:relation_options) do
+              { required: true }
+            end
+
+            context 'when the default config is to require the association' do
+
+              let(:default_require) { true }
+
+              it 'requires the association' do
+                expect(relation.save).to be(false)
+              end
+            end
+
+            context 'when the default config is to not require the association' do
+
+              let(:default_require) { false }
+
+              it 'requires the association' do
+                expect(relation.save).to be(false)
+              end
+            end
+          end
+
+          context 'when :required is false' do
+
+            let(:relation_options) do
+              { required: false }
+            end
+
+            context 'when the default config is to require the association' do
+
+              let(:default_require) { true }
+
+              it 'does not require the association' do
+                expect(relation.save).to be(true)
+              end
+            end
+
+            context 'when the default config is to not require the association' do
+
+              let(:default_require) { false }
+
+              it 'does not require the association' do
+                expect(relation.save).to be(true)
+              end
+            end
+          end
+        end
+
+        context 'when the relation has the option :optional' do
+
+          context 'when :required is true' do
+
+            context 'when :optional is true' do
+
+              let(:relation_options) do
+                {
+                  required: true,
+                  optional: true
+                }
+              end
+
+              context 'when the default config is to require the association' do
+
+                let(:default_require) { true }
+
+                it 'requires the association' do
+                  expect(relation.save).to be(false)
+                end
+              end
+
+              context 'when the default config is to not require the association' do
+
+                let(:default_require) { false }
+
+                it 'requires the association' do
+                  expect(relation.save).to be(false)
+                end
+              end
+            end
+
+            context 'when :optional is false' do
+
+              let(:relation_options) do
+                {
+                  required: true,
+                  optional: false
+                }
+              end
+
+              context 'when the default config is to require the association' do
+
+                let(:default_require) { true }
+
+                it 'requires the association' do
+                  expect(relation.save).to be(false)
+                end
+              end
+
+              context 'when the default config is to not require the association' do
+
+                let(:default_require) { false }
+
+                it 'requires the association' do
+                  expect(relation.save).to be(false)
+                end
+              end
+            end
+          end
+
+          context 'when :required is false' do
+
+            context 'when :optional is true' do
+
+              let(:relation_options) do
+                {
+                  required: false,
+                  optional: true
+                }
+              end
+
+              context 'when the default config is to require the association' do
+
+                let(:default_require) { true }
+
+                it 'does not require the association' do
+                  expect(relation.save).to be(true)
+                end
+              end
+
+              context 'when the default config is to not require the association' do
+
+                let(:default_require) { true }
+
+                it 'does not require the association' do
+                  expect(relation.save).to be(true)
+                end
+              end
+            end
+
+            context 'when :optional is false' do
+
+              let(:relation_options) do
+                {
+                  required: false,
+                  optional: false
+                }
+              end
+
+              context 'when the default config is to require the association' do
+
+                let(:default_require) { true }
+
+                it 'does not require the association' do
+                  expect(relation.save).to be(true)
+                end
+              end
+
+              context 'when the default config is to not require the association' do
+
+                let(:default_require) { false }
+
+                it 'does not require the association' do
+                  expect(relation.save).to be(true)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context 'when the relation does not have the option :required' do
+
+        context 'when the relation has the option :optional' do
+
+          context 'when :optional is true' do
+
+            let(:relation_options) do
+              { optional: true }
+            end
+
+            context 'when the default config is to require the association' do
+
+              let(:default_require) { true }
+
+              it 'does not require the association' do
+                expect(relation.save).to be(true)
+              end
+            end
+
+            context 'when the default config is to not require the association' do
+
+              let(:default_require) { false }
+
+              it 'does not require the association' do
+                expect(relation.save).to be(true)
+              end
+            end
+          end
+
+          context 'when :optional is false' do
+
+            let(:relation_options) do
+              { optional: false }
+            end
+
+            context 'when the default config is to require the association' do
+
+              let(:default_require) { true }
+
+              it 'requires the association' do
+                expect(relation.save).to be(false)
+              end
+            end
+
+            context 'when the default config is to not require the association' do
+
+              let(:default_require) { false }
+
+              it 'requires the association' do
+                expect(relation.save).to be(false)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'when the relation does not have options' do
+
+      context 'when the default config is to require the association' do
+
+        let(:default_require) { true }
+
+        it 'requires the association' do
+          expect(relation.save).to be(false)
+        end
+      end
+
+      context 'when the default config is to not require the association' do
+
+        let(:default_require) { false }
+
+        it 'does not require the association' do
+          expect(relation.save).to be(true)
+        end
+      end
     end
 
     context "when the relation is polymorphic" do
@@ -247,6 +603,19 @@ describe Mongoid::Relations::Macros do
 
     context "when defining the relation" do
 
+      context 'when the relation name is invalid' do
+
+        let(:relation) do
+          klass.belongs_to(:fields)
+        end
+
+        it 'raises an InvalidRelation exception' do
+          expect {
+            relation
+          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+        end
+      end
+
       before do
         klass.belongs_to(:person)
       end
@@ -306,6 +675,19 @@ describe Mongoid::Relations::Macros do
 
     context "when defining the relation" do
 
+      context 'when the relation name is invalid' do
+
+        let(:relation) do
+          klass.has_many(:fields)
+        end
+
+        it 'raises an InvalidRelation exception' do
+          expect {
+            relation
+          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+        end
+      end
+
       before do
         klass.has_many(:posts)
       end
@@ -364,8 +746,8 @@ describe Mongoid::Relations::Macros do
         expect(metadata.order).to_not be_nil
       end
 
-      it "returns Origin::Key" do
-        expect(metadata.order).to be_kind_of(Origin::Key)
+      it "returns Mongoid::Criteria::Queryable::Key" do
+        expect(metadata.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
       end
     end
 
@@ -389,6 +771,19 @@ describe Mongoid::Relations::Macros do
 
     context "when defining the relation" do
 
+      context 'when the relation name is invalid' do
+
+        let(:relation) do
+          klass.has_and_belongs_to_many(:fields)
+        end
+
+        it 'raises an InvalidRelation exception' do
+          expect {
+            relation
+          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+        end
+      end
+
       before do
         klass.has_and_belongs_to_many(:preferences)
       end
@@ -429,8 +824,8 @@ describe Mongoid::Relations::Macros do
           expect(metadata.order).to_not be_nil
         end
 
-        it "returns Origin::Key" do
-          expect(metadata.order).to be_kind_of(Origin::Key)
+        it "returns Mongoid::Criteria::Queryable::Key" do
+          expect(metadata.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
         end
       end
 
@@ -459,6 +854,19 @@ describe Mongoid::Relations::Macros do
 
     context "when defining the relation" do
 
+      context 'when the relation name is invalid' do
+
+        let(:relation) do
+          klass.has_one(:fields)
+        end
+
+        it 'raises an InvalidRelation exception' do
+          expect {
+            relation
+          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+        end
+      end
+
       before do
         klass.has_one(:game)
       end

data/spec/mongoid/relations/metadata_spec.rb

@@ -1896,6 +1896,21 @@ describe Mongoid::Relations::Metadata do
       end
     end
 
+    context "when touch specifies additional field" do
+
+      let(:metadata) do
+        described_class.new(
+          name: :versions,
+          relation: Mongoid::Relations::Referenced::In,
+          touch: :changed_at
+        )
+      end
+
+      it "returns true" do
+        expect(metadata).to be_touchable
+      end
+    end
+
     context "when touch is nil" do
 
       let(:metadata) do
@@ -1967,5 +1982,4 @@ describe Mongoid::Relations::Metadata do
       end
     end
   end
-
 end

data/spec/mongoid/relations/proxy_spec.rb

@@ -19,7 +19,9 @@ describe Mongoid::Relations::Proxy do
 
     it 'uses the new persistence options' do
       expect {
-        animal.with(write: { w: 100 }).update_attribute(:name, 'kangaroo')
+        animal.with(write: { w: 100 }) do |an|
+          an.update_attribute(:name, 'kangaroo')
+        end
       }.to raise_exception(Mongo::Error::OperationFailure)
     end
   end
@@ -95,4 +97,28 @@ describe Mongoid::Relations::Proxy do
       end
     end
   end
+
+  describe "equality" do
+    let(:messages) do
+      Person.create.messages
+    end
+
+    it "is #equal? to itself" do
+      expect(messages.equal?(messages)).to eq(true)
+    end
+
+    it "is == to itself" do
+      expect(messages == messages).to eq(true)
+    end
+
+    it "is not #equal? to its target" do
+      expect(messages.equal?(messages.target)).to eq(false)
+      expect(messages.target.equal?(messages)).to eq(false)
+    end
+
+    it "is == to its target" do
+      expect(messages == messages.target).to eq(true)
+      expect(messages.target == messages).to eq(true)
+    end
+  end
 end

data/spec/mongoid/relations/referenced/in_spec.rb

@@ -264,6 +264,44 @@ describe Mongoid::Relations::Referenced::In do
 
       context "when the relation is not polymorphic" do
 
+        context 'when the child has persistence options set' do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:post) do
+            Post.new
+          end
+
+          before do
+            post.with(collection: 'other-posts') do |p|
+              person.with(collection: 'other-people') do |per|
+                p.person = person
+                per.save
+                p.save
+              end
+            end
+          end
+
+          let(:other_people_count) do
+            Person.with(collection: 'other-people') do |person_class|
+              person_class.count
+            end
+          end
+
+          let(:other_posts_count) do
+            Post.with(collection: 'other-posts') do |post_class|
+              post_class.count
+            end
+          end
+
+          it 'applies the persistence options when saving the child' do
+            expect(other_people_count).to eq(1)
+            expect(other_posts_count).to eq(1)
+          end
+        end
+
         context "when the child is a new record" do
 
           let(:person) do
@@ -1028,7 +1066,9 @@ describe Mongoid::Relations::Referenced::In do
           :index,
           :polymorphic,
           :primary_key,
-          :touch
+          :touch,
+          :optional,
+          :required
         ]
       )
     end