mongoid 7.2.2 → 7.2.6

data/spec/integration/app_spec.rb

@@ -297,6 +297,9 @@ describe 'Mongoid application tests' do
   end
 
   def remove_bundler_req
+    return unless File.file?('Gemfile.lock')
+    # TODO: Remove this method completely when we get rid of .lock files in
+    # mongoid-demo apps.
     lock_lines = IO.readlines('Gemfile.lock')
     # Get rid of the bundled with line so that whatever bundler is installed
     # on the system is usable with the application.

data/spec/integration/contextual/empty_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Contextual classes when dealing with empty result set' do
+  shared_examples 'behave as expected' do
+    context '#exists?' do
+      it 'is false' do
+        context.exists?.should be false
+      end
+    end
+
+    context '#count' do
+      it 'is 0' do
+        context.count.should == 0
+      end
+    end
+
+    context '#length' do
+      it 'is 0' do
+        context.length.should == 0
+      end
+    end
+
+    # #estimated_count only exists for Mongo
+
+    context '#distinct' do
+      it 'is empty array' do
+        context.distinct(:foo).should == []
+      end
+    end
+
+    context '#each' do
+      context 'with block' do
+        it 'does not invoke the block' do
+          called = false
+          context.each do
+            called = true
+          end
+          called.should be false
+        end
+      end
+
+      context 'without block' do
+        it 'returns Enumerable' do
+          context.each.should be_a(Enumerable)
+        end
+
+        it 'returns empty Enumerable' do
+          context.each.to_a.should == []
+        end
+      end
+    end
+
+    context '#map' do
+      context 'with block' do
+        it 'does not invoke the block' do
+          called = false
+          context.map do
+            called = true
+          end
+          called.should be false
+        end
+      end
+
+      context 'without block' do
+        it 'returns empty array' do
+          skip 'MONGOID-5148'
+
+          context.map(:field).should == []
+        end
+      end
+    end
+
+    context '#first' do
+      it 'is nil' do
+        context.first.should be nil
+      end
+    end
+
+    context '#find_first' do
+      it 'is nil' do
+        context.find_first.should be nil
+      end
+    end
+
+    context '#one' do
+      it 'is nil' do
+        context.one.should be nil
+      end
+    end
+
+    context '#last' do
+      it 'is nil' do
+        context.last.should be nil
+      end
+    end
+  end
+
+  let(:context) do
+    context_cls.new(criteria)
+  end
+
+  before do
+    # Create an object of the same class used in the Criteria instance
+    # to verify we are using the Contextual classes.
+    Mop.create!
+  end
+
+  context 'Mongo' do
+    let(:context_cls) { Mongoid::Contextual::Mongo }
+
+    let(:criteria) do
+      Mop.and(Mop.where(a: 1), Mop.where(a: 2))
+    end
+
+    include_examples 'behave as expected'
+  end
+
+  context 'Memory' do
+    let(:context_cls) { Mongoid::Contextual::Memory }
+
+    let(:criteria) do
+      Mop.all.tap do |criteria|
+        criteria.documents = []
+      end
+    end
+
+    include_examples 'behave as expected'
+  end
+
+  context 'None' do
+    let(:context_cls) { Mongoid::Contextual::None }
+
+    let(:criteria) do
+      Mop.none
+    end
+
+    include_examples 'behave as expected'
+  end
+end

data/spec/integration/stringified_symbol_field_spec.rb

@@ -31,8 +31,8 @@ describe "StringifiedSymbol fields" do
     end
   end
 
-# Using command monitoring to test that StringifiedSymbol sends a string and returns a symbol
-let(:client) { Order.collection.client }
+  # Using command monitoring to test that StringifiedSymbol sends a string and returns a symbol
+  let(:client) { Order.collection.client }
 
   before do
     client.subscribe(Mongo::Monitoring::COMMAND, subscriber)

data/spec/mongoid/association/embedded/embeds_many/proxy_spec.rb

@@ -2449,13 +2449,26 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
     end
 
     context "when providing a criteria class method" do
+      context "without keyword arguments" do
 
-      let(:addresses) do
-        person.addresses.california
+        let(:addresses) do
+          person.addresses.california
+        end
+
+        it "applies the criteria to the documents" do
+          expect(addresses).to eq([ address_one ])
+        end
       end
 
-      it "applies the criteria to the documents" do
-        expect(addresses).to eq([ address_one ])
+      context "with keyword arguments" do
+
+        let(:addresses) do
+          person.addresses.city_and_state(city: "Sacramento", state: "CA")
+        end
+
+        it "applies the criteria to the documents" do
+          expect(addresses).to eq([])
+        end
       end
     end
 

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

@@ -1332,4 +1332,21 @@ describe Mongoid::Association::Referenced::BelongsTo::Proxy do
       end
     end
   end
+
+  describe "#method_missing" do
+      let!(:person) do
+        Person.create
+      end
+
+      let!(:game) do
+        Game.create(person: person)
+      end
+
+    it 'handles keyword args' do
+      expect do
+        game.person.set_personal_data(ssn: '123', age: 25)
+      end.not_to raise_error
+    end
+
+  end
 end

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

@@ -35,4 +35,24 @@ describe Mongoid::Association::Referenced::BelongsTo do
       expect(school.team).to eq('Bulldogs')
     end
   end
+
+  context 'when projecting with #only while having similar inverse_of candidates' do
+    before do
+      alice = HmmOwner.create!(name: 'Alice')
+      bob = HmmOwner.create!(name: 'Bob')
+
+      HmmPet.create!(name: 'Rex', current_owner: bob, previous_owner: alice)
+    end
+
+    let(:pet) { HmmPet.where(name: 'Rex').only(:name, :previous_owner_id, 'previous_owner.name').first }
+
+    it 'populates specified fields' do
+      expect(pet.name).to eq('Rex')
+      expect(pet.previous_owner.name).to eq('Alice')
+    end
+
+    it 'does not try to load the inverse for an association that explicitly prevents it' do
+      expect { pet.previous_owner.name }.not_to raise_error
+    end
+  end
 end

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

@@ -24,6 +24,23 @@ class HmmAddress
   belongs_to :company, class_name: 'HmmCompany'
 end
 
+class HmmOwner
+  include Mongoid::Document
+
+  has_many :pets, class_name: 'HmmPet', inverse_of: :current_owner
+
+  field :name, type: String
+end
+
+class HmmPet
+  include Mongoid::Document
+
+  belongs_to :current_owner, class_name: 'HmmOwner', inverse_of: :pets, optional: true
+  belongs_to :previous_owner, class_name: 'HmmOwner', inverse_of: nil, optional: true
+
+  field :name, type: String
+end
+
 class HmmSchool
   include Mongoid::Document
 

data/spec/mongoid/clients/factory_spec.rb

@@ -65,9 +65,15 @@ describe Mongoid::Clients::Factory do
             expect(client).to be_a(Mongo::Client)
           end
 
-          it 'does not produce driver warnings' do
-            Mongo::Logger.logger.should_not receive(:warn)
-            client
+          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
           end
 
           let(:cluster_addresses) do

data/spec/mongoid/clients/options_spec.rb

@@ -83,9 +83,11 @@ describe Mongoid::Clients::Options, retry: 3 do
 
         let!(:connections_and_cluster_during) do
           connections = nil
-          cluster = Minim.with(options) do |klass|
+          cluster = nil
+          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
@@ -124,7 +126,10 @@ describe Mongoid::Clients::Options, retry: 3 do
           end
 
           it 'disconnects the new cluster when the block exits' do
-            expect(connections_before).to eq(connections_after)
+            expect(cluster_after).not_to be(cluster_during)
+
+            cluster_during.connected?.should be false
+            cluster_before.connected?.should be true
           end
         end
 
@@ -138,11 +143,14 @@ 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/config/environment_spec.rb

@@ -5,9 +5,19 @@ require "spec_helper"
 
 describe Mongoid::Config::Environment do
 
-  after(:all) do
-    Rails = RailsTemp
-    Object.send(:remove_const, :RailsTemp)
+  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
   end
 
   describe "#env_name" do
@@ -24,11 +34,6 @@ 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
@@ -86,4 +91,77 @@ 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

data/spec/mongoid/contextual/atomic_spec.rb

@@ -801,27 +801,28 @@ describe Mongoid::Contextual::Atomic do
           context.unset(:name)
         end
 
-        it "unsets the first existing field" do
-          expect(depeche_mode.reload.name).to be_nil
-        end
-
-        it "unsets the last existing field" do
-          expect(new_order.reload.name).to be_nil
+        it "unsets the fields from all documents" do
+          depeche_mode.reload
+          new_order.reload
+          expect(depeche_mode.name).to be_nil
+          expect(depeche_mode.years).to_not be_nil
+          expect(new_order.name).to be_nil
+          expect(new_order.years).to_not be_nil
         end
       end
 
       context "when the field is aliased" do
-
         before do
           context.unset(:years)
         end
 
-        it "unsets the first existing field" do
-          expect(depeche_mode.reload.years).to be_nil
-        end
-
-        it "unsets the last existing field" do
-          expect(new_order.reload.years).to be_nil
+        it "unsets the fields from all documents" do
+          depeche_mode.reload
+          new_order.reload
+          expect(depeche_mode.name).to_not be_nil
+          expect(depeche_mode.years).to be_nil
+          expect(new_order.name).to_not be_nil
+          expect(new_order.years).to be_nil
         end
       end
     end
@@ -829,7 +830,8 @@ describe Mongoid::Contextual::Atomic do
     context "when unsetting multiple fields" do
 
       let!(:new_order) do
-        Band.create(name: "New Order", genres: [ "electro", "dub" ], years: 10)
+        Band.create(name: "New Order", genres: %w[electro dub], years: 10,
+          likes: 200, rating: 4.3, origin: 'Space')
       end
 
       let(:criteria) do
@@ -846,12 +848,13 @@ describe Mongoid::Contextual::Atomic do
           context.unset(:name, :genres)
         end
 
-        it "unsets name field" do
-          expect(new_order.reload.name).to be_nil
-        end
-
-        it "unsets genres field" do
-          expect(new_order.reload.genres).to be_nil
+        it "unsets the specified fields" do
+          new_order.reload
+          expect(new_order.name).to be_nil
+          expect(new_order.genres).to be_nil
+          expect(new_order.years).to_not be_nil
+          expect(new_order.likes).to_not be_nil
+          expect(new_order.rating).to_not be_nil
         end
       end
 
@@ -861,12 +864,46 @@ describe Mongoid::Contextual::Atomic do
           context.unset(:name, :years)
         end
 
-        it "unsets the unaliased field" do
-          expect(new_order.reload.name).to be_nil
+        it "unsets the specified fields" do
+          new_order.reload
+          expect(new_order.name).to be_nil
+          expect(new_order.genres).to_not be_nil
+          expect(new_order.years).to be_nil
+          expect(new_order.likes).to_not be_nil
+          expect(new_order.rating).to_not be_nil
+        end
+      end
+
+      context "when using Hash arguments" do
+
+        before do
+          context.unset({ years: true, likes: "" }, { rating: false, origin: nil })
+        end
+
+        it "unsets the specified fields" do
+          new_order.reload
+          expect(new_order.name).to_not be_nil
+          expect(new_order.genres).to_not be_nil
+          expect(new_order.years).to be_nil
+          expect(new_order.likes).to be_nil
+          expect(new_order.rating).to be_nil
+          expect(new_order.origin).to be_nil
+        end
+      end
+
+      context "when mixing argument types" do
+
+        before do
+          context.unset(:name, [:years], { likes: "" }, { rating: false })
         end
 
-        it "unsets the aliased field" do
-          expect(new_order.reload.years).to be_nil
+        it "unsets the specified fields" do
+          new_order.reload
+          expect(new_order.name).to be_nil
+          expect(new_order.genres).to_not be_nil
+          expect(new_order.years).to be_nil
+          expect(new_order.likes).to be_nil
+          expect(new_order.rating).to be_nil
         end
       end
     end
@@ -895,7 +932,9 @@ describe Mongoid::Contextual::Atomic do
       end
 
       it "unsets the unaliased field" do
-        expect(depeche_mode.reload.name).to be_nil
+        depeche_mode.reload
+        expect(depeche_mode.name).to be_nil
+        expect(depeche_mode.years).to_not be_nil
       end
     end
   end