mongoid 5.4.0 → 6.4.8

data/spec/mongoid/clients/options_spec.rb

@@ -2,185 +2,486 @@ require "spec_helper"
 
 describe Mongoid::Clients::Options do
 
-  describe "#with", if: non_legacy_server? do
+  describe '#with', if: non_legacy_server? do
 
-    context "when passing some options" do
+    context 'when passing some options' do
 
-      let(:options) { { database: 'test' } }
-
-      let!(:cluster) do
-        Band.mongo_client.cluster
+      let(:persistence_context) do
+        Band.with(options) do |klass|
+          klass.persistence_context
+        end
       end
 
-      let!(:klass) do
-        Band.with(options)
+      let(:options) { { database: 'other' } }
+
+      it 'sets the options on the client' do
+        expect(persistence_context.client.options['database']).to eq(options[:database])
       end
 
-      it "sets the options into the class" do
-        expect(klass.persistence_options).to eq(options)
+      it 'does not set the options on class level' do
+        expect(Band.persistence_context.client.options['database']).to eq('mongoid_test')
       end
 
-      it "sets the options into the instance" do
-        expect(klass.new.persistence_options).to eq(options)
+      context 'when the options are not valid mongo client options' do
+
+        let(:persistence_context) do
+          Band.with(invalid_options) do |klass|
+            klass.persistence_context
+          end
+        end
+
+        let(:invalid_options) { { bad: 'option' } }
+
+        it 'raises an error' do
+          expect {
+            persistence_context
+          }.to raise_exception(Mongoid::Errors::InvalidPersistenceOption)
+        end
+
+        it 'clears the persistence context' do
+          begin; persistence_context; rescue Mongoid::Errors::InvalidPersistenceOption; end
+          expect(Band.persistence_context).to eq(Mongoid::PersistenceContext.new(Band))
+        end
       end
 
-      it "doesnt set the options on class level" do
-        expect(Band.new.persistence_options).to be_nil
+      context 'when the options include a collection' do
+
+        let(:options) { { collection: 'another-collection' } }
+
+        it 'uses the collection' do
+          expect(persistence_context.collection_name).to eq(options[:collection].to_sym)
+          expect(persistence_context.collection.name).to eq(options[:collection])
+        end
+
+        it 'does not raise an error' do
+          expect(persistence_context.client).to be_a(Mongo::Client)
+        end
+
+        it 'does not include the collection option in the client options' do
+          expect(persistence_context.client.options[:collection]).to be_nil
+          expect(persistence_context.client.options['collection']).to be_nil
+        end
       end
 
-      context 'when passed a block', if: testing_locally? do
+      context 'when passing a block', if: testing_locally? do
 
         let!(:connections_before) do
           Band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
         end
 
-        it "can return results" do
-          Band.create(name: 'emily')
-          result = Band.with(:read => {:mode => :secondary_preferred}) do |klass|
+        let!(:connections_and_cluster_during) do
+          connections = nil
+          cluster = Band.with(options) do |klass|
             klass.where(name: 'emily').to_a
+            connections = Band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
           end
-          expect(result.length).to eq(1)
-          expect(result.first.name).to eq('emily')
+          [ connections, cluster ]
         end
 
-        before do
-          Band.with(options) do |klass|
-            klass.where(name: 'emily').to_a
-          end
+        let(:connections_during) do
+          connections_and_cluster_during[0]
+        end
+
+        let(:cluster_during) do
+          connections_and_cluster_during[1]
         end
 
         let(:connections_after) do
           Band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
         end
 
-        context 'when a new cluster is created by the driver' do
+        let!(:cluster_before) do
+          Band.persistence_context.cluster
+        end
+
+        let(:cluster_after) do
+          Band.persistence_context.cluster
+        end
 
-          let(:options) { { connect_timeout: 2 } }
+        context 'when the options create a new cluster' do
 
-          it 'disconnects the new cluster' do
-            expect(connections_after).to eq(connections_before)
+          let(:options) do
+            { connect_timeout: 2 }
+          end
+
+          it 'creates a new cluster' do
+            expect(connections_before).to be <(connections_during)
+            expect(cluster_before).not_to be(cluster_during)
+          end
+
+          it 'disconnects the new cluster when the block exits' do
+            expect(connections_before).to eq(connections_after)
           end
         end
 
-        context 'when the same cluster is used by the new client' do
+        context 'when the options do not create a new cluster' do
 
-          let(:options) { { database: 'same-cluster' } }
+          let(:options) do
+            { database: 'same-cluster' }
+          end
+
+          it 'does not create a new cluster' do
+            expect(connections_during).to eq(connections_before)
+          end
 
           it 'does not disconnect the original cluster' do
             expect(connections_after).to eq(connections_before)
+            expect(cluster_before).to be(cluster_after)
+          end
+        end
+
+        context 'when the client options were configured using a uri' do
+
+          let(:config) do
+            {
+                default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
+                secondary: { uri: "mongodb://127.0.0.1:27017/secondary-db?connectTimeoutMS=3000" }
+            }
+          end
+
+          before do
+            Mongoid::Config.send(:clients=, config)
+          end
+
+          after do
+            persistence_context.client.close
+          end
+
+          let(:persistence_context) do
+            Band.with(client: :secondary) do |klass|
+              klass.persistence_context
+            end
+          end
+
+          it 'uses the database specified in the uri' do
+            expect(persistence_context.database_name).to eq('secondary-db')
+            expect(persistence_context.client.database.name).to eq('secondary-db')
+          end
+
+          it 'uses the options specified in the uri' do
+            expect(persistence_context.client.options[:connect_timeout]).to eq(3)
           end
         end
       end
 
-      context "when calling .collection method" do
+      context 'when changing the collection' do
 
-        before do
-          klass.collection
+        let(:options) do
+          { collection: 'other' }
         end
 
-        it "keeps the options" do
-          expect(klass.persistence_options).to eq(options)
+        it 'uses that collection' do
+          expect(persistence_context.collection.name).to eq(options[:collection])
         end
+      end
 
-        context 'when changing the collection' do
+      context 'when returning a criteria' do
 
-          let(:options) do
-            { collection: 'other' }
+        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
+
+          let(:persistence_context) do
+            context_and_criteria[0]
+          end
+
+          let(:client) do
+            context_and_criteria[1].client
           end
 
-          it 'uses that collection' do
-            expect(klass.collection.name).to eq(options[:collection])
+          it 'applies the options to the criteria client' do
+            expect(client.options['read']).to eq('mode' => :secondary)
           end
         end
+
+        context 'read: :secondary shorthand' do
+          let(:read_secondary_option) { {read: :secondary} }
+
+          it_behaves_like 'applies secondary read preference'
+        end
+
+        context 'read: {mode: :secondary}' do
+          let(:read_secondary_option) { {read: {mode: :secondary}} }
+
+          it_behaves_like 'applies secondary read preference'
+        end
       end
 
-      context "when returning a criteria" do
+      context 'when the object is shared between threads' do
 
-        let(:criteria) do
-          klass.all
+        before do
+          threads = []
+          100.times do |i|
+            threads << Thread.new do
+              if i % 2 == 0
+                Band.with(collection: 'British') do |klass|
+                  klass.create(name: 'realised')
+                end
+              else
+                Band.with(collection: 'American') do |klass|
+                  klass.create(name: 'realized')
+                end
+              end
+            end
+          end
+          threads.collect { |t| t.value }
         end
 
-        it "sets the options into the criteria object" do
-          expect(criteria.persistence_options).to eq(options)
+        let(:british_count) do
+          Band.with(collection: 'British') do |klass|
+            klass.all.count
+          end
         end
 
-        it "doesnt set the options on class level" do
-          expect(Band.new.persistence_options).to be_nil
+        let(:american_count) do
+          Band.with(collection: 'American') do |klass|
+            klass.all.count
+          end
+        end
+
+        it "does not share the persistence options" do
+          expect(british_count).to eq(50)
+          expect(american_count).to eq(50)
         end
       end
     end
-  end
 
-  describe ".with", if: non_legacy_server? do
+    context 'when passing a persistence context' do
 
-    let(:options) { { database: 'test' } }
+      let(:instance) do
+        Band.new
+      end
 
-    let(:instance) do
-      Band.new.with(options)
-    end
+      let(:persistence_context) do
+        instance.with(options) do |inst|
+          inst.persistence_context
+        end
+      end
 
-    it "sets the options into" do
-      expect(instance.persistence_options).to eq(options)
-    end
+      let(:options) { { database: 'other' } }
 
-    it "passes down the options to collection" do
-      expect(instance.collection.database.name).to eq('test')
+      it 'sets the persistence context on the object' do
+        Band.new.with(persistence_context) do |band_instance|
+          expect(band_instance.persistence_context.options).to eq(persistence_context.options)
+        end
+      end
     end
+  end
 
-    context "when the object is shared between threads" do
-
-      before do
-        threads = []
-        doc = Band.create(name: "Beatles")
-        100.times do |i|
-          threads << Thread.new do
-            if i % 2 == 0
-              doc.with(nil).set(name: "Rolling Stones")
-            else
-              doc.with(options).set(name: "Beatles")
-            end
+  describe '.with', if: non_legacy_server? do
+
+    context 'when passing some options' do
+
+      let(:options) do
+        { database: 'other' }
+      end
+
+      let(:band) do
+        Band.create
+      end
+
+      let(:persistence_context) do
+        band.with(options) do |object|
+          object.persistence_context
+        end
+      end
+
+      it 'sets the options on the client' do
+        expect(persistence_context.client.options['database']).to eq(options[:database])
+      end
+
+      it 'does not set the options on instance level' do
+        expect(band.persistence_context.client.database.name).to eq('mongoid_test')
+      end
+
+      context 'when the options are not valid mongo client options' do
+
+        let(:persistence_context) do
+          band.with(invalid_options) do |object|
+            object.persistence_context
           end
         end
-        threads.join
+
+        let(:invalid_options) { { bad: 'option' } }
+
+        it 'raises an error' do
+          expect {
+            persistence_context
+          }.to raise_exception(Mongoid::Errors::InvalidPersistenceOption)
+        end
+
+        it 'clears the persistence context' do
+          begin; persistence_context; rescue Mongoid::Errors::InvalidPersistenceOption; end
+          expect(band.persistence_context).to eq(Mongoid::PersistenceContext.new(band))
+        end
       end
 
-      it "does not share the persistence options" do
-        expect(Band.persistence_options).to eq(nil)
+      context 'when the client options were configured using a uri' do
+
+        let(:config) do
+          {
+              default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
+              secondary: { uri: "mongodb://127.0.0.1:27017/secondary-db" }
+          }
+        end
+
+        before do
+          Mongoid::Config.send(:clients=, config)
+        end
+
+        let(:persistence_context) do
+          band.with(client: :secondary) do |object|
+            object.persistence_context
+          end
+        end
+
+        it 'uses the database specified in the uri' do
+          expect(persistence_context.database_name).to eq('secondary-db')
+          expect(persistence_context.client.database.name).to eq('secondary-db')
+        end
       end
-    end
-  end
 
-  describe "#persistence_options" do
+      context 'when passing a block', if: testing_locally? do
 
-    it "touches the thread local" do
-      expect(Thread.current).to receive(:[]).with("[mongoid][Band]:persistence-options").and_return({foo: :bar})
-      expect(Band.persistence_options).to eq({foo: :bar})
-    end
+        let!(:connections_before) do
+          band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
+        end
 
-    it "cannot force a value on thread local" do
-      expect {
-        Band.set_persistence_options(Band, {})
-      }.to raise_error(NoMethodError)
-    end
-  end
+        let(:connections_and_cluster_during) do
+          connections = nil
+          cluster = band.with(options) do |b|
+            b.reload
+            connections = band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
+            b.persistence_context.cluster
+          end
+          [ connections, cluster ]
+        end
+
+        let(:connections_during) do
+          connections_and_cluster_during[0]
+        end
+
+        let(:cluster_during) do
+          connections_and_cluster_during[1]
+        end
+
+        let(:connections_after) do
+          band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
+        end
+
+        let!(:cluster_before) do
+          band.persistence_context.cluster
+        end
+
+        let(:cluster_after) do
+          band.persistence_context.cluster
+        end
+
+        context 'when the options create a new cluster' do
+
+          let(:options) do
+            { connect_timeout: 2 }
+          end
+
+          it 'creates a new cluster' do
+            expect(connections_before).to be <(connections_during)
+            expect(cluster_before).not_to be(cluster_during)
+          end
+
+          it 'disconnects the new cluster when the block exits' do
+            expect(connections_after).to eq(connections_before)
+          end
+        end
+
+        context 'when the options do not create a new cluster' do
 
-  describe ".persistence_options" do
+          let(:options) { { read: :secondary } }
 
-    context "when options exist on the current thread" do
+          it 'does not create a new cluster' do
+            expect(connections_during).to eq(connections_before)
+          end
 
-      let(:klass) do
-        Band.with(write: { w: 2 })
+          it 'does not disconnect the original cluster' do
+            expect(connections_after).to eq(connections_before)
+            expect(cluster_before).to be(cluster_after)
+          end
+        end
       end
 
-      it "returns the options" do
-        expect(klass.persistence_options).to eq(write: { w: 2 })
+      context 'when changing the collection' do
+
+        let(:options) do
+          { collection: 'other' }
+        end
+
+        it 'uses that collection' do
+          expect(persistence_context.collection.name).to eq(options[:collection])
+        end
+      end
+
+      context 'when the object is shared between threads' do
+
+        before do
+          threads = []
+          100.times do |i|
+            band = Band.create
+            threads << Thread.new do
+              if i % 2 == 0
+                band.with(collection: 'British') do |b|
+                  b.name = 'realised'
+                  b.upsert
+                end
+              else
+                band.with(collection: 'American') do |b|
+                  b.name = 'realized'
+                  b.upsert
+                end
+              end
+            end
+          end
+          threads.collect { |t| t.value }
+        end
+
+        let(:british_count) do
+          Band.with(collection: 'British') do |klass|
+            klass.all.count
+          end
+        end
+
+        let(:american_count) do
+          Band.with(collection: 'British') do |klass|
+            klass.all.count
+          end
+        end
+
+        it 'does not share the persistence options' do
+          expect(british_count).to eq(50)
+          expect(american_count).to eq(50)
+        end
       end
     end
 
-    context "when there are no options on the current thread" do
+    context 'when passing a persistence context' do
 
-      it "returns nil" do
-        expect(Band.persistence_options).to be_nil
+      let(:persistence_context) do
+        Band.with(options) do |klass|
+          klass.persistence_context
+        end
+      end
+
+      let(:options) { { database: 'other' } }
+
+      it 'sets the persistence context on the object' do
+        Band.with(persistence_context) do |band_class|
+          expect(band_class.persistence_context.options).to eq(persistence_context.options)
+        end
       end
     end
   end