mongoid 9.0.11 → 9.1.0

data/spec/mongoid/clients/factory_spec.rb

@@ -1,16 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Clients::Factory do
-
   shared_examples_for 'includes seed address' do
     let(:configured_address) do
       address = SpecConfig.instance.addresses.first
-      unless address.include?(':')
-        address = "#{address}:27017"
-      end
+      address = "#{address}:27017" unless address.include?(':')
       address
     end
 
@@ -18,7 +14,7 @@ describe Mongoid::Clients::Factory do
       [
         configured_address,
         configured_address.sub(/\Alocalhost:/, '127.0.0.1:'),
-        configured_address.sub(/\A127\.0\.0\.1:/, 'localhost:'),
+        configured_address.sub(/\A127\.0\.0\.1:/, 'localhost:')
       ].uniq
     end
 
@@ -33,9 +29,9 @@ describe Mongoid::Clients::Factory do
   shared_examples_for 'includes rails wrapping library' do
     context 'when Rails is available' do
       around do |example|
-        rails_was_defined = defined?(::Rails)
+        rails_was_defined = defined?(Rails)
 
-        if !rails_was_defined
+        unless rails_was_defined
           module ::Rails
             def self.version
               '6.1.0'
@@ -45,26 +41,21 @@ describe Mongoid::Clients::Factory do
 
         example.run
 
-        if !rails_was_defined
-          Object.send(:remove_const, :Rails) if defined?(::Rails)
-        end
+        Object.send(:remove_const, :Rails) if !rails_was_defined && defined?(Rails)
       end
 
       it 'adds Rails as another wrapping library' do
         expect(client.options[:wrapping_libraries]).to include(
-          {'name' => 'Rails', 'version' => '6.1.0'},
+          { 'name' => 'Rails', 'version' => '6.1.0' }
         )
       end
     end
   end
 
-  describe ".create" do
-
-    context "when provided a name" do
-
-      context "when the configuration exists" do
-
-        context "when the configuration is standard" do
+  describe '.create' do
+    context 'when provided a name' do
+      context 'when the configuration exists' do
+        context 'when the configuration is standard' do
           restore_config_clients
 
           let(:config) do
@@ -73,6 +64,15 @@ describe Mongoid::Clients::Factory do
               analytics: { hosts: SpecConfig.instance.addresses, database: database_id }
             }
           end
+          let(:client) do
+            described_class.create(:analytics)
+          end
+          let(:cluster) do
+            client.cluster
+          end
+          let(:cluster_addresses) do
+            cluster.addresses.map(&:to_s)
+          end
 
           before do
             Mongoid::Config.send(:clients=, config)
@@ -82,30 +82,17 @@ describe Mongoid::Clients::Factory do
             client.close
           end
 
-          let(:client) do
-            described_class.create(:analytics)
-          end
-
-          let(:cluster) do
-            client.cluster
-          end
-
-          it "returns a client" do
+          it 'returns a client' do
             expect(client).to be_a(Mongo::Client)
           end
 
           context 'on driver versions that do not report spurious EOF errors' do
-
             it 'does not produce driver warnings' do
               Mongo::Logger.logger.should_not receive(:warn)
               client
             end
           end
 
-          let(:cluster_addresses) do
-            cluster.addresses.map(&:to_s)
-          end
-
           it_behaves_like 'includes seed address'
 
           it "sets the platform to Mongoid's platform constant" do
@@ -113,14 +100,14 @@ describe Mongoid::Clients::Factory do
           end
 
           it 'sets Mongoid as a wrapping library' do
-            client.options[:wrapping_libraries].should == [BSON::Document.new(
-              Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY)]
+            client.options[:wrapping_libraries].should eq [ BSON::Document.new(
+              Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY
+            ) ]
           end
 
           it_behaves_like 'includes rails wrapping library'
 
           context 'when configuration specifies a wrapping library' do
-
             let(:config) do
               {
                 default: { hosts: SpecConfig.instance.addresses, database: database_id },
@@ -128,16 +115,16 @@ describe Mongoid::Clients::Factory do
                   hosts: SpecConfig.instance.addresses,
                   database: database_id,
                   options: {
-                    wrapping_libraries: [{name: 'Foo'}],
-                  },
+                    wrapping_libraries: [ { name: 'Foo' } ]
+                  }
                 }
               }
             end
 
             it 'adds Mongoid as another wrapping library' do
-              client.options[:wrapping_libraries].should == [
+              client.options[:wrapping_libraries].should eq [
                 BSON::Document.new(Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY),
-                {'name' => 'Foo'},
+                { 'name' => 'Foo' }
               ]
             end
 
@@ -145,60 +132,62 @@ describe Mongoid::Clients::Factory do
           end
         end
 
-        context "when the configuration has no ports" do
+        context 'when the configuration has no ports' do
           restore_config_clients
 
           let(:config) do
             {
-              default: { hosts: [ "127.0.0.1" ], database: database_id },
-              analytics: { hosts: [ "127.0.0.1" ], database: database_id }
+              default: { hosts: [ '127.0.0.1' ], database: database_id },
+              analytics: { hosts: [ '127.0.0.1' ], database: database_id }
             }
           end
-
-          before do
-            Mongoid::Config.send(:clients=, config)
-          end
-
-          after do
-            client.close
-          end
-
           let(:client) do
             described_class.create(:analytics)
           end
-
           let(:default) do
             described_class.create(:default)
           end
-
           let(:cluster) do
             client.cluster
           end
 
-          it "returns a client" do
+          before do
+            Mongoid::Config.send(:clients=, config)
+          end
+
+          after do
+            client.close
+          end
+
+          it 'returns a client' do
             expect(client).to be_a(Mongo::Client)
           end
 
           it "sets the cluster's seed ports to 27017" do
-            expect(%w(127.0.0.1:27017 localhost:27017)).to include(cluster.addresses.first.to_s)
+            expect(%w[127.0.0.1:27017 localhost:27017]).to include(cluster.addresses.first.to_s)
           end
 
-          it "sets ips with no ports to 27017" do
-            expect(%w(127.0.0.1:27017 localhost:27017)).to include(cluster.addresses.first.to_s)
+          it 'sets ips with no ports to 27017' do
+            expect(%w[127.0.0.1:27017 localhost:27017]).to include(cluster.addresses.first.to_s)
           end
         end
 
-        context "when configured via a uri" do
-
-          context "when the uri has a single host:port" do
+        context 'when configured via a uri' do
+          context 'when the uri has a single host:port' do
             restore_config_clients
 
             let(:config) do
               {
-                default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
-                analytics: { uri: "mongodb://127.0.0.1:27017/mongoid_test" }
+                default: { hosts: [ '127.0.0.1:27017' ], database: database_id },
+                analytics: { uri: 'mongodb://127.0.0.1:27017/mongoid_test' }
               }
             end
+            let(:client) do
+              described_class.create(:analytics)
+            end
+            let(:cluster) do
+              client.cluster
+            end
 
             before do
               Mongoid::Config.send(:clients=, config)
@@ -208,74 +197,62 @@ describe Mongoid::Clients::Factory do
               client.close
             end
 
-            let(:client) do
-              described_class.create(:analytics)
-            end
-
-            let(:cluster) do
-              client.cluster
-            end
-
-            it "returns a client" do
+            it 'returns a client' do
               expect(client).to be_a(Mongo::Client)
             end
 
             it "sets the cluster's seeds" do
-              expect(%w(127.0.0.1:27017 localhost:27017)).to include(cluster.addresses.first.to_s)
+              expect(%w[127.0.0.1:27017 localhost:27017]).to include(cluster.addresses.first.to_s)
             end
 
-            it "sets the database" do
-              expect(client.options[:database]).to eq("mongoid_test")
+            it 'sets the database' do
+              expect(client.options[:database]).to eq('mongoid_test')
             end
           end
 
-          context "when the uri has multiple host:port pairs" do
+          context 'when the uri has multiple host:port pairs' do
             restore_config_clients
 
             let(:config) do
               {
-                default: { hosts: [ "127.0.0.1:1234" ], database: database_id, server_selection_timeout: 1 },
-                analytics: { uri: "mongodb://127.0.0.1:1234,127.0.0.1:5678/mongoid_test?serverSelectionTimeoutMS=1000" }
+                default: { hosts: [ '127.0.0.1:1234' ], database: database_id, server_selection_timeout: 1 },
+                analytics: { uri: 'mongodb://127.0.0.1:1234,127.0.0.1:5678/mongoid_test?serverSelectionTimeoutMS=1000' }
               }
             end
-
-            before do
-              Mongoid::Config.send(:clients=, config)
-            end
-
-            after do
-              client.close
-            end
-
             let(:client) do
               described_class.create(:analytics)
             end
-
             let(:cluster) do
               client.cluster
             end
-
             let(:seeds) do
-              cluster.addresses.map{ |address| address.to_s }
+              cluster.addresses.map { |address| address.to_s }
+            end
+
+            before do
+              Mongoid::Config.send(:clients=, config)
+            end
+
+            after do
+              client.close
             end
 
-            it "returns a client" do
+            it 'returns a client' do
               expect(client).to be_a(Mongo::Client)
             end
 
             it "sets the cluster's seeds" do
-              expect(seeds).to eq([ "127.0.0.1:1234", "127.0.0.1:5678" ])
+              expect(seeds).to eq([ '127.0.0.1:1234', '127.0.0.1:5678' ])
             end
           end
         end
       end
 
-      context "when the configuration does not exist" do
-
-        it "raises an error" do
-          expect {
+      context 'when the configuration does not exist' do
+        it 'raises an error' do
+          expect do
             described_class.create(:unknown)
-          }.to raise_error(Mongoid::Errors::NoClientConfig)
+          end.to raise_error(Mongoid::Errors::NoClientConfig)
         end
       end
 
@@ -316,7 +293,7 @@ describe Mongoid::Clients::Factory do
             }
           end
 
-          it "returns a client" do
+          it 'returns a client' do
             expect(client).to be_a(Mongo::Client)
           end
 
@@ -345,7 +322,7 @@ describe Mongoid::Clients::Factory do
             }
           end
 
-          it "returns a client" do
+          it 'returns a client' do
             expect(client).to be_a(Mongo::Client)
           end
 
@@ -356,41 +333,38 @@ describe Mongoid::Clients::Factory do
       end
     end
 
-    context "when no name is provided" do
+    context 'when no name is provided' do
       restore_config_clients
 
       let(:config) do
-        { default: { hosts: SpecConfig.instance.addresses, database: database_id }}
+        { default: { hosts: SpecConfig.instance.addresses, database: database_id } }
       end
-
-      before do
-        Mongoid::Config.send(:clients=, config)
-      end
-
-      after do
-        client.close
-      end
-
       let(:client) do
         described_class.create
       end
-
       let(:cluster) do
         client.cluster
       end
-
       let(:cluster_addresses) do
         cluster.addresses.map(&:to_s)
       end
 
-      it "returns the default client" do
+      before do
+        Mongoid::Config.send(:clients=, config)
+      end
+
+      after do
+        client.close
+      end
+
+      it 'returns the default client' do
         expect(client).to be_a(Mongo::Client)
       end
 
       it_behaves_like 'includes seed address'
     end
 
-    context "when nil is provided and no default config" do
+    context 'when nil is provided and no default config' do
       restore_config_clients
 
       let(:config) { nil }
@@ -399,47 +373,44 @@ describe Mongoid::Clients::Factory do
         Mongoid.clients[:default] = nil
       end
 
-      it "raises NoClientsConfig error" do
-        expect{ Mongoid::Clients::Factory.create(config) }.to raise_error(Mongoid::Errors::NoClientsConfig)
+      it 'raises NoClientsConfig error' do
+        expect { Mongoid::Clients::Factory.create(config) }.to raise_error(Mongoid::Errors::NoClientsConfig)
       end
     end
   end
 
-  describe ".default" do
+  describe '.default' do
     restore_config_clients
 
     let(:config) do
-      { default: { hosts: SpecConfig.instance.addresses, database: database_id }}
-    end
-
-    before do
-      Mongoid::Config.send(:clients=, config)
-    end
-
-    after do
-      client.close
+      { default: { hosts: SpecConfig.instance.addresses, database: database_id } }
     end
-
     let(:client) do
       described_class.default
     end
-
     let(:cluster) do
       client.cluster
     end
-
     let(:cluster_addresses) do
       cluster.addresses.map(&:to_s)
     end
 
-    it "returns the default client" do
+    before do
+      Mongoid::Config.send(:clients=, config)
+    end
+
+    after do
+      client.close
+    end
+
+    it 'returns the default client' do
       expect(client).to be_a(Mongo::Client)
     end
 
     it_behaves_like 'includes seed address'
   end
 
-  context "when options are provided with string keys" do
+  context 'when options are provided with string keys' do
     restore_config_clients
 
     let(:config) do
@@ -448,44 +419,41 @@ describe Mongoid::Clients::Factory do
           hosts: SpecConfig.instance.addresses,
           database: database_id,
           options: {
-            "server_selection_timeout" => 10,
-            "write" => { "w" => 1 }
+            'server_selection_timeout' => 10,
+            'write' => { 'w' => 1 }
           }
         }
       }
     end
-
-    before do
-      Mongoid::Config.send(:clients=, config)
-    end
-
-    after do
-      client.close
-    end
-
     let(:client) do
       described_class.default
     end
-
     let(:cluster) do
       client.cluster
     end
-
     let(:cluster_addresses) do
       cluster.addresses.map(&:to_s)
     end
 
-    it "returns the default client" do
+    before do
+      Mongoid::Config.send(:clients=, config)
+    end
+
+    after do
+      client.close
+    end
+
+    it 'returns the default client' do
       expect(client).to be_a(Mongo::Client)
     end
 
     it_behaves_like 'includes seed address'
 
-    it "sets the server selection timeout" do
+    it 'sets the server selection timeout' do
       expect(cluster.options[:server_selection_timeout]).to eq(10)
     end
 
-    it "sets the write concern" do
+    it 'sets the write concern' do
       expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
     end
 
@@ -494,21 +462,21 @@ describe Mongoid::Clients::Factory do
     end
   end
 
-  context "unexpected config options" do
+  context 'unexpected config options' do
     restore_config_clients
 
     let(:unknown_opts) do
       {
         bad_one: 1,
-        another_one: "here"
+        another_one: 'here'
       }
     end
 
     let(:config) do
       {
         default: { hosts: SpecConfig.instance.addresses, database: database_id },
-        good_one: { hosts: [ "127.0.0.1:1234" ], database: database_id},
-        bad_one: { hosts: [ "127.0.0.1:1234" ], database: database_id}.merge(unknown_opts),
+        good_one: { hosts: [ '127.0.0.1:1234' ], database: database_id },
+        bad_one: { hosts: [ '127.0.0.1:1234' ], database: database_id }.merge(unknown_opts),
         good_two: { uri: "mongodb://127.0.0.1:1234,127.0.0.1:5678/#{database_id}" },
         bad_two: { uri: "mongodb://127.0.0.1:1234,127.0.0.1:5678/#{database_id}" }.merge(unknown_opts)
       }
@@ -518,14 +486,14 @@ describe Mongoid::Clients::Factory do
       Mongoid::Config.send(:clients=, config)
     end
 
-    [:bad_one, :bad_two].each do |env|
+    %i[bad_one bad_two].each do |env|
       it 'does not log a warning if none' do
         expect(described_class.send(:default_logger)).not_to receive(:warn)
         described_class.create(env).close
       end
     end
 
-    [:bad_one, :bad_two].each do |env|
+    %i[bad_one bad_two].each do |env|
       it 'logs a warning if some' do
         expect(described_class.send(:default_logger)).not_to receive(:warn)
         described_class.create(env).close