mongoid 6.3.0 → 6.4.5

data/spec/mongoid/clients/options_spec.rb

@@ -177,25 +177,40 @@ describe Mongoid::Clients::Options do
 
       context 'when returning a criteria' do
 
-        let(:context_and_criteria) do
-          collection = nil
-          cxt = Band.with(read: :secondary) do |klass|
-            collection = klass.all.collection
-            klass.persistence_context
+        shared_context 'applies secondary read preference' do
+
+          let(:context_and_criteria) do
+            collection = nil
+            cxt = Band.with(read_secondary_option) do |klass|
+              collection = klass.all.collection
+              klass.persistence_context
+            end
+            [ cxt, collection ]
           end
-          [ cxt, collection ]
-        end
 
-        let(:persistence_context) do
-          context_and_criteria[0]
+          let(:persistence_context) do
+            context_and_criteria[0]
+          end
+
+          let(:client) do
+            context_and_criteria[1].client
+          end
+
+          it 'applies the options to the criteria client' do
+            expect(client.options['read']).to eq('mode' => :secondary)
+          end
         end
 
-        let(:client) do
-          context_and_criteria[1].client
+        context 'read: :secondary shorthand' do
+          let(:read_secondary_option) { {read: :secondary} }
+
+          it_behaves_like 'applies secondary read preference'
         end
 
-        it 'applies the options to the criteria client' do
-          expect(client.options['read']).to eq(:secondary)
+        context 'read: {mode: :secondary}' do
+          let(:read_secondary_option) { {read: {mode: :secondary}} }
+
+          it_behaves_like 'applies secondary read preference'
         end
       end
 
@@ -339,7 +354,7 @@ describe Mongoid::Clients::Options do
           band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
         end
 
-        let!(:connections_and_cluster_during) do
+        let(:connections_and_cluster_during) do
           connections = nil
           cluster = band.with(options) do |b|
             b.reload
@@ -381,7 +396,7 @@ describe Mongoid::Clients::Options do
           end
 
           it 'disconnects the new cluster when the block exits' do
-            expect(connections_before).to eq(connections_after)
+            expect(connections_after).to eq(connections_before)
           end
         end
 

data/spec/mongoid/clients/sessions_spec.rb

@@ -0,0 +1,334 @@
+require "spec_helper"
+
+describe Mongoid::Clients::Sessions do
+
+  before(:all) do
+    CONFIG[:clients][:other] = CONFIG[:clients][:default].dup
+    CONFIG[:clients][:other][:database] = 'other'
+    Mongoid::Clients.clients.values.each(&:close)
+    Mongoid::Config.send(:clients=, CONFIG[:clients])
+    Mongoid::Clients.with_name(:other).subscribe(Mongo::Monitoring::COMMAND, EventSubscriber.new)
+  end
+
+  after(:all) do
+    Mongoid::Clients.with_name(:other).close
+    Mongoid::Clients.clients.delete(:other)
+  end
+
+  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.subscribers['Command'].find do |s|
+      s.is_a?(EventSubscriber)
+    end
+  end
+
+  let(:insert_events) do
+    # Driver 2.5 sends command_name as a symbol
+    subscriber.started_events.select { |event| event.command_name.to_s == 'insert' }
+  end
+
+  let(:update_events) do
+    # Driver 2.5 sends command_name as a symbol
+    subscriber.started_events.select { |event| event.command_name.to_s == 'update' }
+  end
+
+  context 'when a session is used on a model class' do
+
+    context 'when sessions are supported', if: sessions_supported? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        subscriber.clear_events!
+        Person.with(client: :other) do
+          example.run
+        end
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+      end
+
+      context 'when another thread is started' do
+
+        let!(:last_use_diff) do
+          Person.with_session do |session|
+            Person.create
+            Person.create
+            last_use = session.instance_variable_get(:@server_session).last_use
+            Thread.new { Person.create }.value
+            session.instance_variable_get(:@server_session).last_use - last_use
+          end
+        end
+
+        it 'does not use the session for that thread' do
+          expect(Person.count).to be(2)
+          expect(Person.with(client: :default) { Person.count }).to be(1)
+          lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+          expect(last_use_diff).to eq(0)
+        end
+      end
+
+      context 'when the operations in the session block are all on the class' do
+
+        before do
+          Person.with_session do
+            Person.create
+            Person.create
+          end
+        end
+
+        it 'uses a single session id for all operations on the class' do
+          expect(Person.count).to be(2)
+          lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the session block are also on another class' do
+
+        context 'when the other class uses the same client' do
+
+          before do
+            Post.with(client: :other) do
+              Person.with_session do
+                Person.create
+                Person.create
+                Post.create
+              end
+            end
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(Post.with(client: :other) { |klass| klass.count }).to be(1)
+            lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(lsids_sent.size).to eq(3)
+            expect(lsids_sent.uniq.size).to eq(1)
+          end
+        end
+
+        context 'when the other class uses a different client' do
+
+          let!(:error) do
+            e = nil
+            begin
+              Person.with_session do
+                Person.create
+                Person.create
+                Post.create
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(Person.count).to be(2)
+            lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(lsids_sent.size).to eq(2)
+            expect(lsids_sent.uniq.size).to eq(1)
+          end
+        end
+
+        context 'when sessions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              Person.with_session do
+                Person.with_session do
+                  Person.create
+                  Post.create
+                end
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'does not execute any operations' do
+            expect(Person.count).to be(0)
+            expect(insert_events).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'when sessions are not supported', unless: sessions_supported? do
+
+      let!(:error) do
+        e = nil
+        begin
+          Person.with_session {}
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a sessions not supported error' do
+        expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+        expect(error.message).to include('not supported')
+      end
+    end
+  end
+
+  context 'when a session is used on a model instance' do
+
+    let!(:person) do
+      Person.with(client: :other) do |klass|
+        klass.create
+      end
+    end
+
+    context 'when sessions are supported', if: sessions_supported? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        subscriber.clear_events!
+        person.with(client: :other) do
+          example.run
+        end
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+      end
+
+      context 'when the operations in the session block are all on the instance' do
+
+        before do
+          person.with_session do
+            person.username = 'Emily'
+            person.save
+            person.age = 80
+            person.save
+          end
+        end
+
+        it 'uses a single session id for all operations on the class' do
+          expect(person.reload.username).to eq('Emily')
+          expect(person.reload.age).to eq(80)
+          lsids_sent = update_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the session block are also on another class' do
+
+        context 'when the other class uses the same client' do
+
+          before do
+            Post.with(client: :other) do
+              person.with_session do
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+              end
+            end
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(person.reload.username).to eq('Emily')
+            expect(Post.with(client: :other) { Post.count }).to be(1)
+            update_lsids_sent = update_events.collect { |event| event.command['lsid'] }
+            expect(update_lsids_sent.size).to eq(3) # person update, counter cache, post assignment
+            expect(update_lsids_sent.uniq.size).to eq(1) # person update, counter cache, post assignment
+            insert_lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(insert_lsids_sent.size).to eq(2)
+            expect(insert_lsids_sent.uniq.size).to eq(1)
+            expect(update_lsids_sent.uniq).to eq(insert_lsids_sent.uniq)
+          end
+        end
+
+        context 'when the other class uses a different client' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(person.reload.username).to eq('Emily')
+            expect(Post.count).to be(0)
+            update_lsids_sent = update_events.collect { |event| event.command['lsid'] }
+            expect(update_lsids_sent.size).to eq(1)
+          end
+        end
+
+        context 'when sessions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do
+                person.with_session do
+                  person.username = 'Emily'
+                  person.save
+                  person.posts << Post.create
+                end
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'does not execute any operations' do
+            expect(person.reload.username).not_to eq('Emily')
+            expect(Post.count).to be(0)
+            expect(update_events).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'when sessions are not supported', unless: sessions_supported? do
+
+      let!(:error) do
+        e = nil
+        begin
+          person.with_session {}
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a sessions not supported error' do
+        expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+        expect(error.message).to include('not supported')
+      end
+    end
+  end
+end

data/spec/mongoid/contextual/geo_near_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe Mongoid::Contextual::GeoNear do
+  max_server_version '4.0'
 
   describe "#average_distance" do
 

data/spec/mongoid/contextual/mongo_spec.rb

@@ -275,6 +275,23 @@ describe Mongoid::Contextual::Mongo do
           expect(Band.count).to eq(0)
         end
       end
+
+      context 'when the write concern is unacknowledged' do
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let!(:deleted) do
+          criteria.with(write: { w: 0 }) do |crit|
+            crit.send(method)
+          end
+        end
+
+        it 'returns 0' do
+          expect(deleted).to eq(0)
+        end
+      end
     end
   end
 
@@ -363,6 +380,27 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context 'when the write concern is unacknowledged' do
+
+      before do
+        2.times { Band.create }
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let!(:deleted) do
+        criteria.with(write: { w: 0 }) do |crit|
+          crit.send(method)
+        end
+      end
+
+      it 'returns 0' do
+        expect(deleted).to eq(0)
+      end
+    end
   end
 
   describe "#distinct" do
@@ -413,7 +451,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the distinct field values" do
-        expect(context.distinct(:years)).to eq([ 30, 25 ])
+        expect(context.distinct(:years).sort).to eq([ 25, 30 ])
       end
     end
 
@@ -2325,7 +2363,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it 'creates a pipeline with the selector as one of the $match criteria' do
-        expect(pipeline_match).to include({ :'$text' => { :'$search' => "New Order" } })
+        expect(pipeline_match).to include({ '$text' => { '$search' => "New Order" } })
       end
 
       it 'creates a pipeline with the $exists operator as one of the $match criteria' do