mongoid 7.1.11 → 7.2.0.rc1

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

@@ -6,6 +6,9 @@ class HmmCompany
 
   field :p, type: Integer
   has_many :emails, primary_key: :p, foreign_key: :f, class_name: 'HmmEmail'
+
+  # The addresses are added with different dependency mechanisms in tests:
+  #has_many :addresses, class_name: 'HmmAddress', dependent: :destroy
 end
 
 class HmmEmail
@@ -15,6 +18,12 @@ class HmmEmail
   belongs_to :company, primary_key: :p, foreign_key: :f, class_name: 'HmmCompany'
 end
 
+class HmmAddress
+  include Mongoid::Document
+
+  belongs_to :company, class_name: 'HmmCompany'
+end
+
 class HmmSchool
   include Mongoid::Document
 

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

@@ -6,6 +6,9 @@ class HomCollege
 
   has_one :accreditation, class_name: 'HomAccreditation'
 
+  # The address is added with different dependency mechanisms in tests:
+  #has_one :address, class_name: 'HomAddress', dependent: :destroy
+
   field :state, type: String
 end
 
@@ -24,6 +27,12 @@ class HomAccreditation::Child
   belongs_to :hom_college
 end
 
+class HomAddress
+  include Mongoid::Document
+
+  belongs_to :college, class_name: 'HomCollege'
+end
+
 module HomNs
   class PrefixedParent
     include Mongoid::Document

data/spec/mongoid/atomic/modifiers_spec.rb

@@ -9,6 +9,26 @@ describe Mongoid::Atomic::Modifiers do
     described_class.new
   end
 
+  describe "#push_conflict?" do
+    let(:result) { modifiers.send(:push_conflict?, field) }
+
+    context 'for embeds many subdocument' do
+      context 'when another field on subdocument is being set' do
+        before do
+          modifiers.set('foo.0.a' => 1)
+        end
+
+        let(:field) { 'foo' }
+
+        it 'does not conflict' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+          result.should be false
+        end
+      end
+    end
+  end
+
   describe "#add_to_set" do
 
     context "when the unique adds are empty" do
@@ -344,6 +364,33 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when there is another operation on a sibling of a key which is nested' do
+
+      let(:first_op) do
+        { "addresses.0.name" => 'test' }
+      end
+
+      let(:push_op) do
+        { "addresses.0.locations" => { "street" => "Oxford St" } }
+      end
+
+      before do
+        modifiers.set(first_op)
+        modifiers.push(push_op)
+      end
+
+      it "does not conflict and adds push to top level" do
+        pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+        modifiers.should == {
+          '$set' => { "addresses.0.name" => 'test' },
+          '$push' => {"addresses.0.locations" => {'$each' => [
+            { "street" => "Oxford St" },
+          ]}},
+        }
+      end
+    end
   end
 
   describe "#set" do

data/spec/mongoid/atomic/paths_spec.rb

@@ -268,46 +268,5 @@ describe Mongoid::Atomic::Paths do
         end
       end
     end
-
-    context "when the same class is embedded in multiple associations" do
-
-      let(:customer) do
-        Customer.new
-      end
-
-      context "assignment after saving" do
-
-        it "correctly sets the association for the embedded class" do
-          pending 'MONGOID-5039'
-
-          customer.home_address = CustomerAddress.new
-          customer.work_address = CustomerAddress.new
-
-          expect(customer.home_address.atomic_path).to eq("home_address")
-          expect(customer.work_address.atomic_path).to eq("work_address")
-
-          customer.save!
-
-          customer.home_address = CustomerAddress.new
-          customer.work_address = CustomerAddress.new
-
-          expect(customer.home_address.atomic_path).to eq("home_address")
-          expect(customer.work_address.atomic_path).to eq("work_address")
-        end
-      end
-
-      context "inverse assignment" do
-
-        it "correctly returns the path for each embedded class" do
-          pending 'MONGOID-5039'
-
-          customer.work_address = CustomerAddress.new
-          customer.work_address.addressable = customer
-
-          expect(customer.home_address.atomic_path).to eq("home_address")
-          expect(customer.work_address.atomic_path).to eq("work_address")
-        end
-      end
-    end
   end
 end

data/spec/mongoid/atomic_spec.rb

@@ -362,6 +362,29 @@ describe Mongoid::Atomic do
             )
           end
         end
+
+        context 'when adding nested embedded docs and updating top level embedded doc' do
+          let!(:truck) { Truck.create! }
+          let!(:crate) { truck.crates.create!(volume: 1) }
+
+          before do
+            truck.crates.first.volume = 2
+            truck.crates.first.toys.build(name: 'Bear')
+            truck.crates.build
+          end
+
+          it 'correctly distributes the operations' do
+            pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+            truck.atomic_updates.should == {
+              '$set' => {'crates.0.volume' => 2},
+              '$push' => {'crates.0.toys' => {'$each' => [crate.toys.first.attributes]}},
+              conflicts: {
+                '$push' => {'crates' => {'$each' => [truck.crates.last.attributes]}},
+              },
+            }
+          end
+        end
       end
     end
   end

data/spec/mongoid/attributes/nested_spec.rb

@@ -234,7 +234,7 @@ describe Mongoid::Attributes::Nested do
     end
   end
 
-  describe "##{name}_attributes=" do
+  describe "*_attributes=" do
 
     context "when the parent document is new" do
 

data/spec/mongoid/attributes_spec.rb

@@ -245,97 +245,6 @@ describe Mongoid::Attributes do
         end
       end
 
-      context "when the field was not explicitly defined" do
-
-        context "when excluding with only and the field was not excluded" do
-
-          let(:from_db) do
-            Person.only(:_id).first
-          end
-
-          it "raises an error" do
-            expect {
-              from_db[:undefined_field]
-            }.to raise_error(ActiveModel::MissingAttributeError)
-          end
-        end
-
-        context "when excluding with without and the field was excluded" do
-
-          let(:from_db) do
-            Person.without(:title).first
-          end
-
-          it "raises an error" do
-            expect {
-              from_db[:title]
-            }.to raise_error(ActiveModel::MissingAttributeError)
-          end
-        end
-
-        context "when excluding with without and the field was not excluded" do
-
-          let(:from_db) do
-            Person.without(:title).first
-          end
-
-          it "returns nil" do
-            from_db[:undefined_field].should be nil
-          end
-        end
-      end
-
-      context 'when projecting with #only' do
-        let!(:person) do
-          Person.create(title: 'sir', name: { first_name: 'Jose', language: { name: 'es' } })
-        end
-
-        context 'when projecting an embedded association' do
-          let(:from_db) do
-            Person.only(:name).first
-          end
-
-          context 'when retrieving a field of the association using the dot notation' do
-
-            it 'retrieves the field' do
-              pending 'MONGOID-5032, fixed in 7.3'
-
-              expect(from_db['name.first_name']).to eq 'Jose'
-            end
-          end
-
-          context 'when retrieving a field of a nested association using the dot notation' do
-            it 'retrieves the field' do
-              pending 'MONGOID-5032, fixed in 7.3'
-
-              expect(from_db['name.language.name']).to eq 'es'
-            end
-          end
-        end
-
-        context 'when projecting a sub-association of an embedded association' do
-          let(:from_db) do
-            Person.only('name.language').first
-          end
-
-          context 'when retrieving a field under the projected sub-association' do
-            it 'retrieves the field' do
-              pending 'MONGOID-5032, fixed in 7.3'
-
-              expect(from_db['name.language.name']).to eq 'es'
-            end
-          end
-
-          context 'when retrieving a non-projected field' do
-            it 'raises MissingAttributeError' do
-              expect do
-                from_db['name.first_name']
-              end.to raise_error(ActiveModel::MissingAttributeError)
-            end
-          end
-        end
-      end
-
       context "when the attribute does not exist" do
 
         before do
@@ -420,67 +329,6 @@ describe Mongoid::Attributes do
         expect(terms).to eq(true)
       end
     end
-
-    context 'when the field is not explicitly defined' do
-      let(:bar) { Bar.new }
-
-      before do
-        bar['missing_field'] = 42
-      end
-
-      it 'writes the value into attributes' do
-        bar.attributes.should == {'_id' => bar.id, 'missing_field' => 42}
-      end
-
-      it 'makes the attribute accessible via []' do
-        bar['missing_field'].should == 42
-      end
-
-      context 'when writing fields on a document with projection' do
-
-        let!(:person) do
-          Person.create(title: "sir")
-        end
-
-        context "when excluding with only and the field was not excluded" do
-
-          let(:from_db) do
-            Person.only(:_id).first
-          end
-
-          it "raises an error" do
-            expect {
-              from_db[:undefined_field] = 'x'
-            }.to raise_error(ActiveModel::MissingAttributeError)
-          end
-        end
-
-        context "when excluding with without and the field was excluded" do
-
-          let(:from_db) do
-            Person.without(:title).first
-          end
-
-          it "raises an error" do
-            expect {
-              from_db[:title] = 'x'
-            }.to raise_error(ActiveModel::MissingAttributeError)
-          end
-        end
-
-        context "when excluding with without and the field was not excluded" do
-
-          let(:from_db) do
-            Person.without(:title).first
-          end
-
-          it "writes the value" do
-            from_db[:undefined_field] = 'x'
-            from_db[:undefined_field].should == 'x'
-          end
-        end
-      end
-    end
   end
 
   describe "#_id" do
@@ -1045,50 +893,6 @@ describe Mongoid::Attributes do
         expect(person.age_before_type_cast).to eq("old")
       end
     end
-
-    context 'when reading fields on a document with projection' do
-
-      let!(:person) do
-        Person.create(title: "sir")
-      end
-
-      context "when excluding with only and the field was not excluded" do
-
-        let(:from_db) do
-          Person.only(:_id).first
-        end
-
-        it "raises an error" do
-          expect {
-            from_db.read_attribute(:undefined_field)
-          }.to raise_error(ActiveModel::MissingAttributeError)
-        end
-      end
-
-      context "when excluding with without and the field was excluded" do
-
-        let(:from_db) do
-          Person.without(:title).first
-        end
-
-        it "raises an error" do
-          expect {
-            from_db.read_attribute(:title)
-          }.to raise_error(ActiveModel::MissingAttributeError)
-        end
-      end
-
-      context "when excluding with without and the field was not excluded" do
-
-        let(:from_db) do
-          Person.without(:title).first
-        end
-
-        it "returns nil" do
-          from_db.read_attribute(:undefined_field).should be nil
-        end
-      end
-    end
   end
 
   describe "#attribute_present?" do
@@ -1594,51 +1398,6 @@ describe Mongoid::Attributes do
         expect(dictionary.description).to eq('foo')
       end
     end
-
-    context 'when writing fields on a document with projection' do
-
-      let!(:person) do
-        Person.create(title: "sir")
-      end
-
-      context "when excluding with only and the field was not excluded" do
-
-        let(:from_db) do
-          Person.only(:_id).first
-        end
-
-        it "raises an error" do
-          expect {
-            from_db.write_attribute(:undefined_field, 'x')
-          }.to raise_error(ActiveModel::MissingAttributeError)
-        end
-      end
-
-      context "when excluding with without and the field was excluded" do
-
-        let(:from_db) do
-          Person.without(:title).first
-        end
-
-        it "raises an error" do
-          expect {
-            from_db.write_attribute(:title, 'x')
-          }.to raise_error(ActiveModel::MissingAttributeError)
-        end
-      end
-
-      context "when excluding with without and the field was not excluded" do
-
-        let(:from_db) do
-          Person.without(:title).first
-        end
-
-        it "writes the value" do
-          from_db.write_attribute(:undefined_field, 'x')
-          from_db.read_attribute(:undefined_field).should == 'x'
-        end
-      end
-    end
   end
 
   describe "#typed_value_for" do

data/spec/mongoid/clients/factory_spec.rb

@@ -65,15 +65,9 @@ describe Mongoid::Clients::Factory do
             expect(client).to be_a(Mongo::Client)
           end
 
-          context 'not JRuby' do
-            # Run this test on JRuby when driver 2.16.0 is released -
-            # see RUBY-2771.
-            fails_on_jruby
-
-            it 'does not produce driver warnings' do
-              Mongo::Logger.logger.should_not receive(:warn)
-              client
-            end
+          it 'does not produce driver warnings' do
+            Mongo::Logger.logger.should_not receive(:warn)
+            client
           end
 
           let(:cluster_addresses) do
@@ -85,6 +79,38 @@ describe Mongoid::Clients::Factory do
           it "sets the platform to Mongoid's platform constant" do
             expect(client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
           end
+
+          context 'driver 2.13+' do
+            min_driver_version '2.13'
+
+            it 'sets Mongoid as a wrapping library' do
+              client.options[:wrapping_libraries].should == [BSON::Document.new(
+                Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY)]
+            end
+
+            context 'when configuration specifies a wrapping library' do
+
+              let(:config) do
+                {
+                  default: { hosts: SpecConfig.instance.addresses, database: database_id },
+                  analytics: {
+                    hosts: SpecConfig.instance.addresses,
+                    database: database_id,
+                    options: {
+                      wrapping_libraries: [{name: 'Foo'}],
+                    },
+                  }
+                }
+              end
+
+              it 'adds Mongoid as another wrapping library' do
+                client.options[:wrapping_libraries].should == [
+                  BSON::Document.new(Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY),
+                  {'name' => 'Foo'},
+                ]
+              end
+            end
+          end
         end
 
         context "when the configuration has no ports" do

data/spec/mongoid/clients/options_spec.rb

@@ -83,11 +83,9 @@ describe Mongoid::Clients::Options, retry: 3 do
 
         let!(:connections_and_cluster_during) do
           connections = nil
-          cluster = nil
-          Minim.with(options) do |klass|
+          cluster = Minim.with(options) do |klass|
             klass.where(name: 'emily').to_a
             connections = Minim.mongo_client.database.command(serverStatus: 1).first['connections']['current']
-            cluster = Minim.collection.cluster
           end
           [ connections, cluster ]
         end
@@ -126,10 +124,7 @@ describe Mongoid::Clients::Options, retry: 3 do
           end
 
           it 'disconnects the new cluster when the block exits' do
-            expect(cluster_after).not_to be(cluster_during)
-
-            cluster_during.connected?.should be false
-            cluster_before.connected?.should be true
+            expect(connections_before).to eq(connections_after)
           end
         end
 
@@ -143,14 +138,11 @@ describe Mongoid::Clients::Options, retry: 3 do
 
           it 'does not create a new cluster' do
             expect(connections_during).to eq(connections_before)
-
-            cluster_during.should be cluster_before
           end
 
           it 'does not disconnect the original cluster' do
+            expect(connections_after).to eq(connections_before)
             expect(cluster_before).to be(cluster_after)
-
-            cluster_before.connected?.should be true
           end
         end
 

data/spec/mongoid/clients/sessions_spec.rb

@@ -20,12 +20,7 @@ describe Mongoid::Clients::Sessions do
 
   let(:subscriber) do
     client = Mongoid::Clients.with_name(:other)
-    monitoring = if client.respond_to?(:monitoring, true)
-      client.send(:monitoring)
-    else
-      # driver 2.5
-      client.instance_variable_get('@monitoring')
-    end
+    monitoring = client.send(:monitoring)
     monitoring.subscribers['Command'].find do |s|
       s.is_a?(EventSubscriber)
     end

data/spec/mongoid/config/environment_spec.rb

@@ -5,19 +5,9 @@ require "spec_helper"
 
 describe Mongoid::Config::Environment do
 
-  around do |example|
-    if defined?(Rails)
-      SavedRails = Rails
-      example.run
-      Object.send(:remove_const, :Rails) if defined?(Rails)
-      Rails = SavedRails
-      Object.send(:remove_const, :SavedRails)
-    else
-      example.run
-      if defined?(Rails)
-        Object.send(:remove_const, :Rails)
-      end
-    end
+  after(:all) do
+    Rails = RailsTemp
+    Object.send(:remove_const, :RailsTemp)
   end
 
   describe "#env_name" do
@@ -34,6 +24,11 @@ describe Mongoid::Config::Environment do
           end
         end
 
+        after do
+          RailsTemp = Rails
+          Object.send(:remove_const, :Rails)
+        end
+
         it "returns the rails environment" do
           expect(described_class.env_name).to eq("production")
         end
@@ -91,77 +86,4 @@ describe Mongoid::Config::Environment do
       end
     end
   end
-
-  describe "#load_yaml" do
-    let(:path) { 'mongoid.yml' }
-    let(:environment) {}
-    before { allow(Rails).to receive('env').and_return('test') }
-
-    subject { described_class.load_yaml(path, environment) }
-
-    context 'when file not found' do
-      let(:path) { 'not/a/valid/path'}
-
-      it { expect { subject }.to raise_error(Errno::ENOENT) }
-    end
-
-    context 'when file found' do
-      before do
-        allow(File).to receive(:new).with('mongoid.yml').and_return(StringIO.new(file_contents))
-      end
-
-      let(:file_contents) do
-        <<~FILE
-          test:
-            clients: ['test']
-          development:
-            clients: ['dev']
-        FILE
-      end
-
-      context 'when file cannot be parsed as YAML' do
-        let(:file_contents) { "*\nbad:%123abc" }
-
-        it { expect { subject }.to raise_error(Psych::SyntaxError) }
-      end
-
-      context 'when file contains ERB errors' do
-        let(:file_contents) { '<%= foo %>' }
-
-        it { expect { subject }.to raise_error(NameError) }
-      end
-
-      context 'when file is empty' do
-        let(:file_contents) { '' }
-
-        it { expect { subject }.to raise_error(Mongoid::Errors::EmptyConfigFile) }
-      end
-
-      context 'when file does not contain a YAML Hash object' do
-        let(:file_contents) { '["this", "is", "an", "array"]' }
-
-        it { expect { subject }.to raise_error(Mongoid::Errors::InvalidConfigFile) }
-      end
-
-      context 'when environment not specified' do
-        it 'uses the rails environment' do
-          is_expected.to eq("clients"=>["test"])
-        end
-      end
-
-      context 'when environment is specified' do
-        let(:environment) { 'development' }
-
-        it 'uses the specified environment' do
-          is_expected.to eq("clients"=>["dev"])
-        end
-      end
-
-      context 'when environment is missing' do
-        let(:environment) { 'staging' }
-
-        it { is_expected.to be_nil }
-      end
-    end
-  end
 end