mongoid 6.4.2 → 7.0.3

data/spec/mongoid/clients/transactions_spec.rb

@@ -0,0 +1,369 @@
+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
+    Mongoid::Clients.with_name(:other).send(:monitoring).subscribers['Command'].find do |s|
+      s.is_a?(EventSubscriber)
+    end
+  end
+
+  let(:insert_events) do
+    subscriber.started_events.select { |event| event.command_name == 'insert' }
+  end
+
+  let(:insert_events_txn_numbers) do
+    insert_events.map { |i| i.instance_variable_get(:@integer) }
+  end
+
+  let(:update_events) do
+    subscriber.started_events.select { |event| event.command_name == 'update' }
+  end
+
+  let(:update_events_txn_numbers) do
+    update_events.map { |i| i.instance_variable_get(:@integer) }
+  end
+
+  let(:other_events) do
+    subscriber.started_events.reject { |event| ['insert', 'update'].include?(event.command_name) }
+  end
+
+  context 'when a transaction is used on a model class' do
+
+    context 'when transactions are supported', if: testing_transactions? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        Mongoid::Clients.with_name(:other).command(create: :people)
+        Mongoid::Clients.with_name(:other).command(create: :posts)
+        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 |s|
+            s.start_transaction
+            Person.create
+            Person.create
+            Thread.new { Person.create }.value
+            s.commit_transaction
+          end
+        end
+
+        it 'does not use the transaction for that thread' do
+          expect(Person.count).to be(2)
+          expect(Person.with(client: :default) { Person.count }).to be(1)
+          expect(insert_events.count { |e| e.command['startTransaction'] }).to be(1)
+          expect(other_events.count { |e| e.command_name == 'commitTransaction' }).to be(1)
+        end
+      end
+
+      context 'when the operations in the transactions block are all on the class' do
+
+        before do
+          Person.with_session do |s|
+            s.start_transaction
+            Person.create
+            Person.create
+            s.commit_transaction
+          end
+        end
+
+        it 'uses a single transaction number for all operations on the class' do
+          expect(Person.count).to be(2)
+          expect(insert_events_txn_numbers.size).to eq(2)
+          expect(insert_events_txn_numbers.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the transactions 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 |s|
+                s.start_transaction
+                Person.create
+                Person.create
+                Post.create
+                s.commit_transaction
+              end
+            end
+          end
+
+          it 'uses a single transaction number for all operations on the class' do
+            expect(Post.with(client: :other) { |klass| klass.count }).to be(1)
+            expect(insert_events_txn_numbers.size).to eq(3)
+            expect(insert_events_txn_numbers.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 |s|
+                s.start_transaction
+                Person.create
+                Person.create
+                Post.create
+                s.commit_transaction
+              end
+            rescue => ex
+                e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'aborted the transaction' do
+            expect(Person.count).to be(0)
+            expect(Post.count).to be(0)
+            expect(insert_events_txn_numbers.size).to eq(2)
+            expect(other_events.count { |e| e.command_name == 'abortTransaction'}).to be(1)
+            expect(other_events.count { |e| e.command_name == 'commitTransaction'}).to be(0)
+          end
+        end
+
+        context 'when transactions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              Person.with_session do |s|
+                s.start_transaction
+                s.start_transaction
+                Person.create
+                Post.create
+                s.commit_transaction
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongo::Error::InvalidTransactionOperation)
+          end
+
+          it 'does not execute any operations' do
+            expect(Person.count).to be(0)
+            expect(Post.count).to be(0)
+            expect(insert_events).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'when sessions are supported but transactions are not', if: sessions_supported? && !testing_transactions? do
+
+      let!(:error) do
+        e = nil
+        begin
+          Person.with_session do |s|
+            s.start_transaction
+            Person.create
+            s.commit_transaction
+          end
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a transactions not supported error' do
+        expect(Person.count).to eq(0)
+        expect(error).to be_a(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+
+  context 'when a transaction is used on a model instance' do
+
+    let!(:person) do
+      Person.with(client: :other) do |klass|
+        klass.create
+      end
+    end
+
+    context 'when transactions are supported', if: testing_transactions? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        Mongoid::Clients.with_name(:other).command(create: :people)
+        Mongoid::Clients.with_name(:other).command(create: :posts)
+        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 transaction block are all on the instance' do
+
+        before do
+          person.with_session do |s|
+            s.start_transaction
+            person.username = 'Emily'
+            person.save
+            person.age = 80
+            person.save
+            s.commit_transaction
+          end
+        end
+
+        it 'uses a single transaction number for all operations on the class' do
+          expect(person.reload.username).to eq('Emily')
+          expect(person.reload.age).to eq(80)
+          expect(update_events_txn_numbers.size).to eq(2)
+          expect(update_events_txn_numbers.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the transaction 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 |s|
+                s.start_transaction
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+                s.commit_transaction
+              end
+            end
+          end
+
+          it 'uses a single transaction number for all operations on the class' do
+            expect(person.reload.username).to eq('Emily')
+            expect(Post.with(client: :other) { Post.count }).to be(1)
+            expect(update_events_txn_numbers.size).to eq(3) # person update, counter cache, post assignment
+            expect(update_events_txn_numbers.uniq.size).to eq(1) # person update, counter cache, post assignment
+            expect(insert_events_txn_numbers.size).to eq(2)
+            expect(insert_events_txn_numbers.uniq.size).to eq(1)
+            expect(update_events_txn_numbers.uniq).to eq(insert_events_txn_numbers.uniq)
+          end
+        end
+
+        context 'when the other class uses a different client' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do |s|
+                s.start_transaction
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+                s.commit_transaction
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'aborted the transction' do
+            expect(person.reload.username).not_to eq('Emily')
+            expect(Post.count).to be(0)
+            expect(update_events_txn_numbers.size).to eq(1)
+            expect(insert_events_txn_numbers.size).to eq(1)
+          end
+        end
+
+        context 'when transactions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do |s|
+                s.start_transaction
+                s.start_transaction
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+                s.commit_transaction
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongo::Error::InvalidTransactionOperation)
+          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 supported but transactions are not', if: sessions_supported? && !testing_transactions? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        Mongoid::Clients.with_name(:other).command(create: :people)
+        subscriber.clear_events!
+        person.with(client: :other) do
+          example.run
+        end
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+      end
+
+      let!(:error) do
+        e = nil
+        begin
+          person.with_session do |s|
+            s.start_transaction
+            person.username = 'Emily'
+            person.save
+            s.commit_transaction
+          end
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a sessions not supported error' do
+        expect(person.reload.username).not_to be('Emily')
+        expect(error).to be_a(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end

data/spec/mongoid/clients_spec.rb

@@ -208,6 +208,72 @@ describe Mongoid::Clients do
       end
 
       it_behaves_like "an overridden collection name at the class level"
+
+      context 'when nesting #with calls' do
+        let(:instance_collection_name) do
+          Band.with(collection: "ignore") do |klass|
+            Band.with(collection: "artists") do |klass|
+              klass.new.collection_name
+            end
+          end
+        end
+
+        let(:class_collection_name) do
+          Band.with(collection: "ignore") do |klass|
+            Band.with(collection: "artists") do |klass|
+              klass.collection_name
+            end
+          end
+        end
+
+        it_behaves_like "an overridden collection name at the class level"
+      end
+
+      context 'when outer #with call specifies the collection' do
+        use_spec_mongoid_config
+
+        let(:instance_collection_name) do
+          Band.with(collection: "artists") do |klass|
+            Band.with(client: :reports) do |klass|
+              klass.new.collection_name
+            end
+          end
+        end
+
+        let(:class_collection_name) do
+          Band.with(collection: "artists") do |klass|
+            Band.with(client: :reports) do |klass|
+              klass.collection_name
+            end
+          end
+        end
+
+        it_behaves_like "an overridden collection name at the class level"
+      end
+
+      context 'restores outer context in outer block' do
+        use_spec_mongoid_config
+
+        let(:instance_collection_name) do
+          Band.with(collection: "artists") do |klass|
+            Band.with(collection: "scratch") do |klass|
+              # nothing
+            end
+            klass.new.collection_name
+          end
+        end
+
+        let(:class_collection_name) do
+          Band.with(collection: "artists") do |klass|
+            Band.with(collection: "scratch") do |klass|
+              # nothing
+            end
+            klass.collection_name
+          end
+        end
+
+        it_behaves_like "an overridden collection name at the class level"
+      end
     end
 
     context "when overriding store_in and persistence options" do
@@ -427,7 +493,7 @@ describe Mongoid::Clients do
       let(:client_name) { :alternative }
 
       before do
-        Mongoid.clients[client_name] = { database: database_id_alt, hosts: [ "#{HOST}:#{PORT}" ] }
+        Mongoid.clients[client_name] = { database: database_id_alt, hosts: SpecConfig.instance.addresses }
       end
 
       after do
@@ -552,20 +618,14 @@ describe Mongoid::Clients do
     end
 
     context "when getting a client by name" do
-
-      let(:file) do
-        File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
-      end
+      use_spec_mongoid_config
 
       before do
-        described_class.clear
-        Mongoid.load!(file, :test)
         Band.store_in(client: :reports)
       end
 
       after do
         mongo_client.close
-        Mongoid::Config.reset
         Band.reset_storage_options!
       end
 

data/spec/mongoid/config_spec.rb

@@ -88,6 +88,30 @@ describe Mongoid::Config do
     end
   end
 
+  context 'when background_indexing option' do
+    context 'is not set in the config' do
+      it 'sets the value to false by default' do
+        Mongoid::Config.reset
+        configuration = CONFIG.merge(options: {})
+
+        Mongoid.configure { |config| config.load_configuration(configuration) }
+
+        expect(Mongoid::Config.background_indexing).to be(false)
+      end
+    end
+
+    context 'is set in the config' do
+      it 'sets the value' do
+        Mongoid::Config.reset
+        configuration = CONFIG.merge(options: {background_indexing: true})
+
+        Mongoid.configure { |config| config.load_configuration(configuration) }
+
+        expect(Mongoid::Config.background_indexing).to be(true)
+      end
+    end
+  end
+
   context 'when the belongs_to_required_by_default option is not set in the config' do
 
     before do
@@ -346,7 +370,9 @@ describe Mongoid::Config do
           end
 
           it "sets the default hosts" do
-            expect(default[:hosts]).to eq(["#{HOST}:#{PORT}"])
+            expect(default[:hosts]).to eq(SpecConfig.instance.addresses)
+            # and make sure the value is not empty
+            expect(default[:hosts].first).to include(':')
           end
 
           context "when the default has options" do

data/spec/mongoid/contextual/memory_spec.rb

@@ -987,6 +987,25 @@ describe Mongoid::Contextual::Memory do
     end
   end
 
+  describe '#inc' do
+
+    let(:criteria) do
+      Address.all.tap do |crit|
+        crit.documents = [ Address.new(number: 1),
+                           Address.new(number: 2),
+                           Address.new(number: 3) ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it 'increases each member' do
+      expect(context.inc(number: 10).collect(&:number)).to eql([11, 12, 13])
+    end
+  end
+
   describe "#skip" do
 
     let(:hobrecht) do

data/spec/mongoid/contextual/mongo_spec.rb

@@ -451,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
 
@@ -577,6 +577,31 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context 'when the criteria has a parent document' do
+
+      before do
+        Post.create(person: person)
+        Post.create(person: person)
+        Post.create(person: person)
+      end
+
+      let(:person) do
+        Person.new
+      end
+
+      let(:criteria) do
+        person.posts.all
+      end
+
+      let(:persons) do
+        criteria.collect(&:person)
+      end
+
+      it 'sets the same parent object on each related object' do
+        expect(persons.uniq.size).to eq(1)
+      end
+    end
   end
 
   describe "#eager_load" do
@@ -591,12 +616,12 @@ describe Mongoid::Contextual::Mongo do
 
     context "when no documents are returned" do
 
-      let(:game_metadata) do
+      let(:game_association) do
         Person.reflect_on_association(:game)
       end
 
       it "does not make any additional database queries" do
-        expect(game_metadata).to receive(:eager_load).never
+        expect(game_association).to receive(:eager_load).never
         context.send(:eager_load, [])
       end
     end
@@ -1693,6 +1718,9 @@ describe Mongoid::Contextual::Mongo do
     end
 
     context "when limiting is provided" do
+      # map/reduce with limit is not supported on sharded clusters:
+      # https://jira.mongodb.org/browse/SERVER-2099
+      require_topology :single, :replica_set
 
       let(:criteria) do
         Band.limit(1)
@@ -2328,7 +2356,7 @@ describe Mongoid::Contextual::Mongo do
 
       let!(:update) do
         context.update_all({ '$set' => { 'labels.$[i].name' => 'Sony' } },
-                           array_filters: [{ 'i.name' => 'Cbs' }])
+                       array_filters: [{ 'i.name' => 'Cbs' }])
       end
 
       it 'applies the array filters' do
@@ -2363,7 +2391,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