mongoid 7.0.1 → 7.0.2

data/spec/mongoid/attributes/nested_spec.rb

@@ -12,10 +12,12 @@ describe Mongoid::Attributes::Nested do
 
       before do
         Person.accepts_nested_attributes_for :favorites
+        Person.accepts_nested_attributes_for :children
       end
 
       after do
         Person.send(:undef_method, :favorites_attributes=)
+        Person.send(:undef_method, :children_attributes=)
         Person.nested_attributes.clear
       end
 
@@ -23,9 +25,18 @@ describe Mongoid::Attributes::Nested do
         expect(person).to respond_to(:favorites_attributes=)
       end
 
+      it "does not autosave if the association is embedded" do
+        expect(person).not_to respond_to(:autosave_documents_for_favorites)
+      end
+
+      it "autosaves if the association is not embedded" do
+        expect(person).to respond_to(:autosave_documents_for_children)
+      end
+
       it "adds the method name to the nested attributes list" do
         expect(Person.nested_attributes).to eq({
-          "favorites_attributes" => "favorites_attributes="
+          "favorites_attributes" => "favorites_attributes=",
+          "children_attributes" => "children_attributes="
         })
       end
     end
@@ -202,7 +213,12 @@ describe Mongoid::Attributes::Nested do
     context "when the relation is a referenced in" do
 
       before do
-        Post.accepts_nested_attributes_for :person
+        Post.accepts_nested_attributes_for :person, autosave: false
+      end
+
+      after do
+        Post.send(:undef_method, :person_attributes=)
+        Post.nested_attributes.clear
       end
 
       let(:post) do

data/spec/mongoid/clients/factory_spec.rb

@@ -132,8 +132,8 @@ describe Mongoid::Clients::Factory do
 
             let(:config) do
               {
-                default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
-                secondary: { uri: "mongodb://127.0.0.1:27017,127.0.0.1:27018/mongoid_test" }
+                default: { hosts: [ "127.0.0.1:1234" ], database: database_id },
+                secondary: { uri: "mongodb://127.0.0.1:1234,127.0.0.1:5678/mongoid_test" }
               }
             end
 
@@ -162,7 +162,7 @@ describe Mongoid::Clients::Factory do
             end
 
             it "sets the cluster's seeds" do
-              expect(seeds).to eq([ "127.0.0.1:27017", "127.0.0.1:27018" ])
+              expect(seeds).to eq([ "127.0.0.1:1234", "127.0.0.1:5678" ])
             end
           end
         end

data/spec/mongoid/clients/options_spec.rb

@@ -188,25 +188,40 @@ describe Mongoid::Clients::Options do
 
       context 'when returning a criteria' do
 
-        let(:context_and_criteria) do
-          collection = nil
-          cxt = TestModel.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 = TestModel.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
 

data/spec/mongoid/clients/sessions_spec.rb

@@ -16,17 +16,17 @@ describe Mongoid::Clients::Sessions do
   end
 
   let(:subscriber) do
-    Mongoid::Clients.with_name(:other).instance_variable_get(:@monitoring).subscribers['Command'].find do |s|
+    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 }
+    subscriber.started_events.select { |event| event.command_name == 'insert' }
   end
 
   let(:update_events) do
-    subscriber.started_events.select { |event| event.command_name == :update }
+    subscriber.started_events.select { |event| event.command_name == 'update' }
   end
 
   context 'when a session is used on a model class' do

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