mongoid 5.4.1 → 6.1.1

data/spec/mongoid/relations/embedded/many_spec.rb

@@ -428,22 +428,40 @@ describe Mongoid::Relations::Embedded::Many do
     context "when replacing an existing relation" do
 
       let(:person) do
-        Person.create(addresses: [
+        Person.create(addresses: addresses)
+      end
+
+      let(:addresses) do
+        [
           Address.new(street: "1st St"),
           Address.new(street: "2nd St")
-        ])
+        ]
       end
 
       let(:address) do
         Address.new(street: "3rd St")
       end
 
-      before do
-        person.addresses = [ address ]
+      context "when the replaced relation is different from the existing relation" do
+
+        before do
+          person.addresses = [ address ]
+        end
+
+        it "deletes the old documents" do
+          expect(person.reload.addresses).to eq([ address ])
+        end
       end
 
-      it "deletes the old documents" do
-        expect(person.reload.addresses).to eq([ address ])
+      context "when the replaced relation is identical to the existing relation" do
+
+        before do
+          person.addresses = addresses
+        end
+
+        it "does nothing" do
+          expect(person.reload.addresses).to eq(addresses)
+        end
       end
     end
 
@@ -879,6 +897,36 @@ describe Mongoid::Relations::Embedded::Many do
       Person.create
     end
 
+    context 'when a string is used to access an attribute' do
+
+      let!(:address) do
+        person.addresses.create(street: "one")
+      end
+
+      let(:document) do
+        person.reload.addresses.as_document.first
+      end
+
+      it "returns the attribute value" do
+        expect(document['street']).to eq('one')
+      end
+    end
+
+    context 'when a symbol is used to access an attribute' do
+
+      let!(:address) do
+        person.addresses.create(street: "one")
+      end
+
+      let(:document) do
+        person.reload.addresses.as_document.first
+      end
+
+      it "returns the attribute value" do
+        expect(document[:street]).to eq('one')
+      end
+    end
+
     context "when the relation has no default scope" do
 
       let!(:address) do
@@ -3761,12 +3809,10 @@ describe Mongoid::Relations::Embedded::Many do
 
       before do
         expect(artist).to receive(:before_add_song).and_raise
+        begin; artist.songs << song; rescue; end
       end
 
       it "does not add the document to the relation" do
-        expect {
-          artist.songs << song
-        }.to raise_error
         expect(artist.songs).to be_empty
       end
     end
@@ -3791,12 +3837,10 @@ describe Mongoid::Relations::Embedded::Many do
 
       before do
         expect(artist).to receive(:after_add_label).and_raise
+        begin; artist.labels << label; rescue; end
       end
 
       it "adds the document to the relation" do
-        expect {
-          artist.labels << label
-        }.to raise_error
         expect(artist.labels).to eq([ label ])
       end
     end
@@ -3857,19 +3901,18 @@ describe Mongoid::Relations::Embedded::Many do
         describe "#delete" do
 
           it "does not remove the document from the relation" do
-            expect {
-              artist.songs.delete(song)
-            }.to raise_error
+            begin; artist.songs.delete(song); rescue; end
             expect(artist.songs).to eq([ song ])
           end
         end
 
         describe "#clear" do
 
+          before do
+            begin; artist.songs.clear; rescue; end
+          end
+
           it "removes the documents from the relation" do
-            expect {
-              artist.songs.clear
-            }.to raise_error
             expect(artist.songs).to eq([ song ])
           end
         end
@@ -3925,9 +3968,7 @@ describe Mongoid::Relations::Embedded::Many do
       describe "#delete" do
 
         before do
-          expect {
-            artist.labels.delete(label)
-          }.to raise_error
+          begin; artist.labels.delete(label); rescue; end
         end
 
         it "removes the document from the relation" do
@@ -3938,9 +3979,7 @@ describe Mongoid::Relations::Embedded::Many do
       describe "#clear" do
 
         before do
-          expect {
-            artist.labels.clear
-          }.to raise_error
+          begin; artist.labels.clear; rescue; end
         end
 
         it "should remove from collection" do
@@ -4019,29 +4058,6 @@ describe Mongoid::Relations::Embedded::Many do
     end
   end
 
-  context "when embedded documents get marshalled" do
-
-    let(:person) do
-      Person.create
-    end
-
-    let!(:addresses) do
-      person.addresses
-    end
-
-    let!(:dumped) do
-      Marshal.dump(addresses)
-    end
-
-    let!(:loaded) do
-      Marshal.load(dumped)
-    end
-
-    it "keeps the proxy extensions when remarshalling" do
-      expect(loaded.extension).to eq("Testing")
-    end
-  end
-
   context "deleting embedded documents" do
 
     it "able to delete embedded documents upon condition" do

data/spec/mongoid/relations/embedded/one_spec.rb

@@ -70,7 +70,8 @@ describe Mongoid::Relations::Embedded::One do
               name_without_default or (self.name = Name.new)
             end
             class << person
-              alias_method_chain :name, :default
+              alias_method :name_without_default, :name
+              alias_method :name, :name_with_default
             end
           end
 

data/spec/mongoid/relations/macros_spec.rb

@@ -15,12 +15,30 @@ describe Mongoid::Relations::Macros do
     klass._validators.clear
   end
 
+  after do
+    klass.relations.clear
+    klass.validators.clear
+  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 +92,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 +163,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 +188,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 +267,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 +583,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 +655,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 +726,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 +751,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 +804,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 +834,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