mongoid 7.0.0 → 7.4.0

data/spec/mongoid/clients/transactions_spec.rb

@@ -0,0 +1,415 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Clients::Sessions do
+  before(:all) do
+    if Gem::Version.new(Mongo::VERSION) < Gem::Version.new('2.6')
+      skip 'Driver does not support transactions'
+    end
+  end
+
+  before(:all) do
+    if Gem::Version.new(Mongo::VERSION) >= Gem::Version.new('2.6')
+      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
+  end
+
+  after(:all) do
+    if Gem::Version.new(Mongo::VERSION) >= Gem::Version.new('2.6')
+      Mongoid::Clients.with_name(:other).close
+      Mongoid::Clients.clients.delete(:other)
+    end
+  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' do
+      require_transaction_support
+
+      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)
+        Mongoid::Clients.with_name(:other).command(create: :canvases)
+        subscriber.clear_events!
+        Canvas.with(client: :other) do
+          Person.with(client: :other) do
+            example.run
+          end
+        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
+
+      context 'When reloading an embedded document created inside a transaction' do
+        it 'does not raise an error and has the correct document' do
+          Canvas.with_session do |s|
+            s.start_transaction
+
+            p = Palette.new
+            c = Canvas.new(palette: p)
+            c.save!
+
+            expect do
+              p.reload
+            end.to_not raise_error
+
+            expect(c.palette).to eq(p)
+
+            s.commit_transaction
+          end
+        end
+      end
+    end
+
+    context 'when sessions are supported but transactions are not' do
+      min_server_version '3.6'
+      # Could also test 4.0 in sharded cluster
+      max_server_version '3.6'
+
+      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' do
+      require_transaction_support
+
+      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' do
+      min_server_version '3.6'
+      # Could also test 4.0 in sharded cluster
+      max_server_version '3.6'
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        Mongoid::Clients.with_name(:other).command(create: :people)
+
+        begin
+          subscriber.clear_events!
+          person.with(client: :other) do
+            example.run
+          end
+        ensure
+          Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        end
+      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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Clients do
@@ -208,6 +210,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 +495,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 +620,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
 
@@ -665,7 +727,7 @@ describe Mongoid::Clients do
     end
   end
 
-  describe ".store_in", if: non_legacy_server? do
+  describe ".store_in" do
 
     context "when provided a non hash" do
 
@@ -702,7 +764,7 @@ describe Mongoid::Clients do
     end
   end
 
-  describe ".with", if: non_legacy_server? do
+  describe ".with" do
 
     context "when changing write concern options" do
 
@@ -729,11 +791,11 @@ describe Mongoid::Clients do
         end
       end
 
-      describe ".create" do
+      describe ".create!" do
 
         let!(:band) do
           Band.with(database: database_id_alt) do |klass|
-            klass.create
+            klass.create!
           end
         end
 
@@ -767,11 +829,11 @@ describe Mongoid::Clients do
 
     context "when sending operations to a different collection" do
 
-      describe ".create" do
+      describe ".create!" do
 
         let!(:band) do
           Band.with(collection: "artists") do |klass|
-            klass.create
+            klass.create!
           end
         end
 
@@ -882,7 +944,7 @@ describe Mongoid::Clients do
       describe ".save" do
 
         before do
-          Person.create(ssn: "432-97-1113")
+          Person.create!(ssn: "432-97-1113")
         end
 
         context "when a mongodb error occurs" do
@@ -975,7 +1037,7 @@ describe Mongoid::Clients do
       end
 
       let!(:band) do
-        Band.create(name: "Tool")
+        Band.create!(name: "Tool")
       end
 
       it "persists to the overridden database" do

data/spec/mongoid/composable_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Composable do

data/spec/mongoid/config/environment_spec.rb

@@ -1,10 +1,22 @@
+# frozen_string_literal: true
+
 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
@@ -21,11 +33,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
@@ -83,4 +90,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