mongoid 7.0.3 → 7.0.8

data/spec/lite_spec_helper.rb

@@ -4,7 +4,6 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
 require "mongoid"
-require "rspec"
 
 # MRI 2.5 and JRuby 9.2 change visibility of Object#pp when 'pp' is required,
 # which happens when RSpec reports anything. This creates an issue for tests
@@ -36,16 +35,27 @@ else
 end
 
 RSpec.configure do |config|
+  config.expect_with(:rspec) do |c|
+    c.syntax = [:should, :expect]
+  end
+
   if SpecConfig.instance.ci?
     config.add_formatter(RSpec::Core::Formatters::JsonFormatter, File.join(File.dirname(__FILE__), '../tmp/rspec.json'))
   end
 
   if SpecConfig.instance.ci?
-    # Allow a max of 30 seconds per test.
-    # Tests should take under 10 seconds ideally but it seems
-    # we have some that run for more than 10 seconds in CI.
+    timeout = if SpecConfig.instance.app_tests?
+      # Allow 5 minutes per test for the app tests, since they install
+      # gems for Rails applications which can take a long time.
+      300
+    else
+      # Allow a max of 30 seconds per test.
+      # Tests should take under 10 seconds ideally but it seems
+      # we have some that run for more than 10 seconds in CI.
+      30
+    end
     config.around(:each) do |example|
-      TimeoutInterrupt.timeout(30) do
+      TimeoutInterrupt.timeout(timeout) do
         example.run
       end
     end

data/spec/mongoid/association/embedded/embedded_in_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require_relative './embeds_one_models'
 
 describe Mongoid::Association::Embedded::EmbeddedIn do
 
@@ -313,6 +314,42 @@ describe Mongoid::Association::Embedded::EmbeddedIn do
           it 'returns nil' do
             expect(association.inverses).to eq(nil)
           end
+
+          context 'when class_name is given and is a plain string' do
+            let(:association) do
+              EomParent.relations['child']
+            end
+
+            it 'returns the inverse in an array' do
+              inverses = association.inverses
+              expect(inverses).to eq([:parent])
+            end
+          end
+
+          context 'when class_name is given and is a :: prefixed string' do
+            let(:association) do
+              EomCcChild.relations['parent']
+            end
+
+            it 'returns the inverse in an array' do
+              pending 'MONGOID-4751'
+
+              inverses = association.inverses
+              expect(inverses).to eq([:child])
+            end
+
+            context 'when other associations referencing unloaded classes exist' do
+              let(:association) do
+                EomDnlChild.relations['parent']
+              end
+
+              it 'does not load other classes' do
+                inverses = association.inverses
+                expect(inverses).to eq([:child])
+                expect(Object.const_defined?(:EoDnlMarker)).to be false
+              end
+            end
+          end
         end
       end
     end
@@ -549,6 +586,16 @@ describe Mongoid::Association::Embedded::EmbeddedIn do
       it 'returns the class name option' do
         expect(association.relation_class_name).to eq('OtherContainer')
       end
+
+      context ':class_name is a :: prefixed string' do
+        let(:association) do
+          EomCcChild.relations['parent']
+        end
+
+        it 'returns the :: prefixed string' do
+          expect(association.relation_class_name).to eq('::EomCcParent')
+        end
+      end
     end
 
     context 'when the class_name option is not specified' do
@@ -557,6 +604,17 @@ describe Mongoid::Association::Embedded::EmbeddedIn do
         expect(association.relation_class_name).to eq('Container')
       end
     end
+
+    context 'when another association in the model is referencing a third model class' do
+      let(:association) do
+        EomDnlChild.relations['parent']
+      end
+
+      it 'does not attempt to load the third class' do
+        expect(association.relation_class_name).to eq('EomDnlParent')
+        expect(Object.const_defined?(:EoDnlMarker)).to be false
+      end
+    end
   end
 
   describe '#klass' do

data/spec/mongoid/association/embedded/embeds_many_models.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+class EmmCongress
+  include Mongoid::Document
+
+  embeds_many :legislators, class_name: 'EmmLegislator'
+
+  field :name, type: String
+end
+
+class EmmLegislator
+  include Mongoid::Document
+
+  embedded_in :congress, class_name: 'EmmCongress'
+
+  field :a, type: Integer, default: 0
+  field :b, type: Integer, default: 0
+end
+
+# Models with associations with :class_name as a :: prefixed string
+
+class EmmCcCongress
+  include Mongoid::Document
+
+  embeds_many :legislators, class_name: '::EmmCcLegislator'
+
+  field :name, type: String
+end
+
+class EmmCcLegislator
+  include Mongoid::Document
+
+  embedded_in :congress, class_name: '::EmmCcCongress'
+
+  field :a, type: Integer, default: 0
+  field :b, type: Integer, default: 0
+end
+
+class EmmManufactory
+  include Mongoid::Document
+
+  embeds_many :products, order: :id.desc, class_name: 'EmmProduct'
+end
+
+
+class EmmProduct
+  include Mongoid::Document
+
+  embedded_in :manufactory, class_name: 'EmmManufactory'
+
+  field :name, type: String
+end

data/spec/mongoid/association/embedded/embeds_many_spec.rb

@@ -646,6 +646,16 @@ describe Mongoid::Association::Embedded::EmbedsMany do
       it 'returns the class name option' do
         expect(association.klass).to eq(_class)
       end
+
+      context 'when the class name is prefixed with ::' do
+        let(:options) do
+          { class_name: '::OtherEmbeddedObject' }
+        end
+
+        it 'returns the class name option' do
+          expect(association.klass).to eq(_class)
+        end
+      end
     end
 
     context 'when the class_name option is not specified' do

data/spec/mongoid/association/embedded/embeds_one_dnl_models.rb

@@ -0,0 +1,6 @@
+# This file is added as an autoload target, but should never be actually
+# processed.
+
+# Marker class - if this class exists, this file was attempted to be required.
+class EoDnlMarker
+end

data/spec/mongoid/association/embedded/embeds_one_models.rb

@@ -0,0 +1,51 @@
+class EomParent
+  include Mongoid::Document
+
+  embeds_one :child, class_name: 'EomChild'
+
+  field :name, type: String
+end
+
+class EomChild
+  include Mongoid::Document
+
+  embedded_in :parent, class_name: 'EomParent'
+
+  field :a, type: Integer, default: 0
+  field :b, type: Integer, default: 0
+end
+
+# Models with associations with :class_name as a :: prefixed string
+
+class EomCcParent
+  include Mongoid::Document
+
+  embeds_one :child, class_name: '::EomCcChild'
+end
+
+class EomCcChild
+  include Mongoid::Document
+
+  embedded_in :parent, class_name: '::EomCcParent'
+end
+
+# Models referencing other models which should not be loaded unless the
+# respective association is referenced
+
+autoload :EomDnlMissingChild, 'mongoid/association/embedded/embeds_one_dnl_models'
+
+class EomDnlParent
+  include Mongoid::Document
+
+  embeds_one :child, class_name: 'EomDnlChild'
+  embeds_one :missing_child, class_name: 'EomDnlMissingChild'
+end
+
+autoload :EomDnlMissingParent, 'mongoid/association/embedded/embeds_one_dnl_models'
+
+class EomDnlChild
+  include Mongoid::Document
+
+  embedded_in :parent, class_name: 'EomDnlParent'
+  embedded_in :missing_parent, class_name: 'EomDnlMissingParent'
+end

data/spec/mongoid/association/embedded/embeds_one_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require_relative './embeds_one_models'
 
 describe Mongoid::Association::Embedded::EmbedsOne do
 
@@ -444,6 +445,30 @@ describe Mongoid::Association::Embedded::EmbedsOne do
           it 'returns the :as attribute' do
             expect(association.inverses).to eq([ :containable ])
           end
+
+          context 'when class_name is given and is a :: prefixed string' do
+
+            let(:association) do
+              EomCcParent.relations['child']
+            end
+
+            it 'returns the inverse in an array' do
+              inverses = association.inverses
+              expect(inverses).to eq([:parent])
+            end
+
+            context 'when other associations referencing unloaded classes exist' do
+              let(:association) do
+                EomDnlParent.relations['child']
+              end
+
+              it 'does not load other classes' do
+                inverses = association.inverses
+                expect(inverses).to eq([:parent])
+                expect(Object.const_defined?(:EoDnlMarker)).to be false
+              end
+            end
+          end
         end
       end
     end
@@ -604,6 +629,16 @@ describe Mongoid::Association::Embedded::EmbedsOne do
       it 'returns the class name option' do
         expect(association.relation_class_name).to eq('OtherEmbeddedObject')
       end
+
+      context ':class_name is a :: prefixed string' do
+        let(:association) do
+          EomCcParent.relations['child']
+        end
+
+        it 'returns the :: prefixed string' do
+          expect(association.relation_class_name).to eq('::EomCcChild')
+        end
+      end
     end
 
     context 'when the class_name option is not specified' do
@@ -612,6 +647,17 @@ describe Mongoid::Association::Embedded::EmbedsOne do
         expect(association.relation_class_name).to eq('EmbeddedObject')
       end
     end
+
+    context 'when another association in the model is referencing a third model class' do
+      let(:association) do
+        EomDnlParent.relations['child']
+      end
+
+      it 'does not attempt to load the third class' do
+        expect(association.relation_class_name).to eq('EomDnlChild')
+        expect(Object.const_defined?(:EoDnlMarker)).to be false
+      end
+    end
   end
 
   describe '#klass' do

data/spec/mongoid/association/referenced/belongs_to_spec.rb

@@ -1622,6 +1622,17 @@ describe Mongoid::Association::Referenced::BelongsTo do
       end
     end
 
+    context 'when the :class_name option is scoped with ::' do
+
+      let(:options) do
+        { class_name: '::OtherOwnerObject' }
+      end
+
+      it 'returns the class name option' do
+        expect(association.relation_class_name).to eq('::OtherOwnerObject')
+      end
+    end
+
     context 'when the class_name option is not specified' do
 
       it 'uses the name of the relation to deduce the class name' do
@@ -1644,17 +1655,23 @@ describe Mongoid::Association::Referenced::BelongsTo do
 
     context 'when the :class_name option is specified' do
 
-      let!(:_class) do
-        class OtherOwnerObject; end
-        OtherOwnerObject
+      let(:options) do
+        { class_name: 'OtherOwnerObject' }
+      end
+
+      it 'returns the named class' do
+        expect(association.relation_class).to eq(OtherOwnerObject)
       end
+    end
+
+    context 'when the :class_name option is scoped with ::' do
 
       let(:options) do
-        { class_name: 'OtherOwnerObject' }
+        { class_name: '::OtherOwnerObject' }
       end
 
-      it 'returns the class name option' do
-        expect(association.relation_class).to eq(_class)
+      it 'returns the named class' do
+        expect(association.relation_class).to eq(OtherOwnerObject)
       end
     end
 

data/spec/mongoid/association/referenced/has_and_belongs_to_many/proxy_spec.rb

@@ -2686,7 +2686,8 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
         expect(preferences).to eq([ preference_one ])
       end
 
-      context 'when providing a collation', if: collation_supported? do
+      context 'when providing a collation' do
+        min_server_version '3.4'
 
         let(:preferences) do
           person.preferences.where(name: "FIRST").collation(locale: 'en_US', strength: 2).to_a

data/spec/mongoid/association/referenced/has_many/proxy_spec.rb

@@ -2904,7 +2904,8 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
         expect(posts).to eq([ post_one ])
       end
 
-      context 'when providing a collation', if: collation_supported? do
+      context 'when providing a collation' do
+        min_server_version '3.4'
 
         let(:posts) do
           person.posts.where(title: "FIRST").collation(locale: 'en_US', strength: 2)

data/spec/mongoid/association/referenced/has_one_spec.rb

@@ -909,12 +909,12 @@ describe Mongoid::Association::Referenced::HasOne do
         end
       end
 
-      it 'returns the proper namespaced class name' do
+      it 'returns the inferred unqualified class name' do
         define_classes
 
         expect(
             HasOneAssociationClassName::OwnedClass.relations['owner_class'].relation_class_name
-        ).to eq('HasOneAssociationClassName::OwnerClass')
+        ).to eq('OwnerClass')
       end
     end
 
@@ -945,6 +945,16 @@ describe Mongoid::Association::Referenced::HasOne do
         expect(association.relation_class_name).to eq('BelongingObject')
       end
     end
+
+    context "when the class is not defined" do
+      let(:name) do
+        :undefined_class
+      end
+
+      it 'does not trigger autoloading' do
+        expect(association.relation_class_name).to eq('UndefinedClass')
+      end
+    end
   end
 
   describe '#relation_class' do

data/spec/mongoid/attributes/dynamic_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Attributes::Dynamic do
+  shared_examples_for 'dynamic field' do
+    let(:raw_attributes) do
+      {attr_name => 'foo bar'}
+    end
+
+    context 'when reading attributes' do
+      context 'an unsaved model' do
+        it 'can be read' do
+          bar = Bar.new(raw_attributes)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+
+      context 'saved model' do
+        it 'can be read' do
+          bar = Bar.new(raw_attributes)
+          bar.save!
+
+          bar = Bar.find(bar.id)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+
+      context 'when attribute is not set' do
+        it 'cannot be read' do
+          bar = Bar.new
+          expect do
+            bar.send(attr_name)
+          end.to raise_error(NoMethodError)
+        end
+
+        context 'reading via read_attribute' do
+          it 'returns nil' do
+            bar = Bar.new
+            expect(bar.read_attribute(:foo)).to be nil
+          end
+        end
+
+        context 'reading via []' do
+          it 'returns nil' do
+            bar = Bar.new
+            expect(bar[:foo]).to be nil
+          end
+        end
+      end
+    end
+
+    context 'when writing attributes via constructor' do
+      it 'can be written' do
+        bar = Bar.new(raw_attributes)
+        bar.save!
+
+        bar = Bar.find(bar.id)
+        expect(bar.send(attr_name)).to eq('foo bar')
+      end
+    end
+
+    context 'when writing attributes via attributes=' do
+      it 'can be written' do
+        bar = Bar.new
+        bar.attributes = raw_attributes
+        bar.save!
+
+        bar = Bar.find(bar.id)
+        expect(bar.send(attr_name)).to eq('foo bar')
+      end
+    end
+
+    context 'when writing attributes via write_attribute' do
+      it 'can be written' do
+        bar = Bar.new
+        bar.write_attribute(attr_name, 'foo bar')
+        bar.save!
+
+        bar = Bar.find(bar.id)
+        expect(bar.send(attr_name)).to eq('foo bar')
+      end
+    end
+
+    context 'when writing attributes via []=' do
+      context 'string key' do
+        it 'can be written' do
+          bar = Bar.new
+          bar[attr_name.to_s] = 'foo bar'
+          bar.save!
+
+          bar = Bar.find(bar.id)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+
+      context 'symbol key' do
+        it 'can be written' do
+          bar = Bar.new
+          bar[attr_name.to_sym] = 'foo bar'
+          bar.save!
+
+          bar = Bar.find(bar.id)
+          expect(bar.send(attr_name)).to eq('foo bar')
+        end
+      end
+    end
+
+    context 'when writing attributes via #{attribute}=' do
+      context 'when attribute is not already set' do
+        let(:bar) { Bar.new }
+
+        it 'cannot be written' do
+          expect do
+            bar.send("#{attr_name}=", 'foo bar')
+            bar.save!
+          end.to raise_error(NoMethodError)
+        end
+      end
+
+      context 'when attribute is already set' do
+        let(:bar) { Bar.new(attr_name => 'foo bar') }
+
+        it 'can be written' do
+          bar.send("#{attr_name}=", 'new foo bar')
+          bar.save!
+
+          _bar = Bar.find(bar.id)
+          expect(_bar.send(attr_name)).to eq('new foo bar')
+        end
+      end
+    end
+  end
+
+  context 'when attribute name is alphanumeric' do
+    let(:attr_name) { 'foo' }
+
+    it_behaves_like 'dynamic field'
+  end
+
+  context 'when attribute name contains spaces' do
+    let(:attr_name) { 'hello world' }
+
+    it_behaves_like 'dynamic field'
+  end
+
+  context 'when attribute name contains special characters' do
+    let(:attr_name) { 'hello%world' }
+
+    it_behaves_like 'dynamic field'
+  end
+end