mongo 2.13.3 → 2.14.0.rc1

data/spec/mongo/operation/read_preference_op_msg_spec.rb

@@ -175,13 +175,13 @@ describe Mongo::Operation::SessionsSupported do
         let(:tag_sets) { nil }
 
         context 'without tag_sets specified' do
-          it_behaves_like 'adds read preference'
+          it_behaves_like 'does not modify selector'
         end
 
         context 'with empty tag_sets' do
           let(:tag_sets) { [] }
 
-          it_behaves_like 'adds read preference'
+          it_behaves_like 'does not modify selector'
         end
 
         context 'with tag_sets specified' do
@@ -256,7 +256,7 @@ describe Mongo::Operation::SessionsSupported do
           let(:hedge) { nil }
 
           context 'when tag_sets and hedge are not specified' do
-            it_behaves_like 'adds read preference'
+            it_behaves_like 'does not modify selector'
           end
 
           context 'when tag_sets are specified' do

data/spec/mongo/query_cache_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+describe Mongo::QueryCache do
+
+  around do |spec|
+    Mongo::QueryCache.clear
+    Mongo::QueryCache.cache { spec.run }
+  end
+
+  before do
+    authorized_collection.delete_many
+  end
+
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:authorized_collection) { client['collection_spec'] }
+
+  let(:events) do
+    subscriber.command_started_events('find')
+  end
+
+  describe '#enabled' do
+
+    context 'when query cache is disabled' do
+
+      before do
+        Mongo::QueryCache.enabled = false
+      end
+
+      it 'disables the query cache' do
+        expect(Mongo::QueryCache.enabled?).to be(false)
+      end
+    end
+
+    context 'when query cache is enabled' do
+
+      before do
+        Mongo::QueryCache.enabled = true
+      end
+
+      it 'enables the query cache' do
+        expect(Mongo::QueryCache.enabled?).to be(true)
+      end
+    end
+  end
+
+  describe '#cache' do
+
+    before do
+      Mongo::QueryCache.enabled = false
+    end
+
+    it 'enables the query cache inside the block' do
+      Mongo::QueryCache.cache do
+        expect(Mongo::QueryCache.enabled?).to be(true)
+      end
+      expect(Mongo::QueryCache.enabled?).to be(false)
+    end
+  end
+
+  describe '#uncached' do
+
+    it 'disables the query cache inside the block' do
+      Mongo::QueryCache.uncached do
+        expect(Mongo::QueryCache.enabled?).to be(false)
+      end
+      expect(Mongo::QueryCache.enabled?).to be(true)
+    end
+  end
+
+  describe '#cache_table' do
+
+    before do
+      authorized_collection.insert_one({ name: 'testing' })
+      authorized_collection.find(name: 'testing').to_a
+    end
+
+    it 'gets the cached query' do
+      expect(Mongo::QueryCache.send(:cache_table).length).to eq(1)
+      authorized_collection.find(name: 'testing').to_a
+      expect(events.length).to eq(1)
+    end
+  end
+
+  describe '#clear' do
+
+    before do
+      authorized_collection.insert_one({ name: 'testing' })
+      authorized_collection.find(name: 'testing').to_a
+    end
+
+    it 'clears the cache' do
+      expect(Mongo::QueryCache.send(:cache_table).length).to eq(1)
+      Mongo::QueryCache.clear
+      expect(Mongo::QueryCache.send(:cache_table).length).to eq(0)
+    end
+  end
+
+  describe '#set' do
+    let(:caching_cursor) { double("Mongo::CachingCursor") }
+    let(:namespace) { 'db.coll' }
+    let(:selector) { { field: 'value' } }
+    let(:skip) { 5 }
+    let(:sort) { { field: 'asc' } }
+    let(:limit) { 5 }
+    let(:projection) { { field: 1 } }
+    let(:collation) { { locale: 'fr_CA' } }
+    let(:read_concern) { { level: :majority } }
+    let(:read_preference) { { mode: :secondary } }
+
+    let(:options) do
+      {
+        namespace: namespace,
+        selector: selector,
+        skip: skip,
+        sort: sort,
+        limit: limit,
+        projection: projection,
+        collation: collation,
+        read_concern: read_concern,
+        read_preference: read_preference,
+      }
+    end
+
+    it 'stores the cursor at the correct key' do
+      Mongo::QueryCache.set(caching_cursor, **options)
+      expect(Mongo::QueryCache.send(:cache_table)[namespace][[namespace, selector, skip, sort, projection, collation, read_concern, read_preference]]).to eq(caching_cursor)
+    end
+  end
+
+  describe '#get' do
+    let(:view) { double("Mongo::Collection::View") }
+    let(:result) { double("Mongo::Operation::Result") }
+    let(:server) { double("Mongo::Server") }
+    let(:caching_cursor) { Mongo::CachingCursor.new(view, result, server) }
+
+    let(:options) do
+      {
+        namespace: 'db.coll',
+        selector: { field: 'value' },
+      }
+    end
+
+    before do
+      allow(result).to receive(:cursor_id) { 0 }
+      allow(view).to receive(:limit) { nil }
+    end
+
+    context 'when there is no entry in the cache' do
+      it 'returns nil' do
+        expect(Mongo::QueryCache.get(**options)).to be_nil
+      end
+    end
+
+    context 'when there is an entry in the cache' do
+      before do
+        Mongo::QueryCache.set(caching_cursor, **caching_cursor_options)
+      end
+
+      context 'when that entry has no limit' do
+        let(:caching_cursor_options) do
+          {
+            namespace: 'db.coll',
+            selector: { field: 'value' },
+          }
+        end
+
+        let(:query_options) do
+          caching_cursor_options.merge(limit: limit)
+        end
+
+        context 'when the query has a limit' do
+          let(:limit) { 5 }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+
+        context 'when the query has no limit' do
+          let(:limit) { nil }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+      end
+
+      context 'when that entry has a limit' do
+        let(:caching_cursor_options) do
+          {
+            namespace: 'db.coll',
+            selector: { field: 'value' },
+            limit: 5,
+          }
+        end
+
+        let(:query_options) do
+          caching_cursor_options.merge(limit: limit)
+        end
+
+        before do
+          allow(view).to receive(:limit) { 5 }
+        end
+
+        context 'and the new query has a smaller limit' do
+          let(:limit) { 4 }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+
+        context 'and the new query has a larger limit' do
+          let(:limit) { 6 }
+
+          it 'returns nil' do
+            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+          end
+        end
+
+        context 'and the new query has the same limit' do
+          let(:limit) { 5 }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+
+        context 'and the new query has no limit' do
+          let(:limit) { nil }
+
+          it 'returns nil' do
+            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe '#clear_namespace' do
+    let(:caching_cursor) { double("Mongo::CachingCursor") }
+    let(:namespace1) { 'db.coll' }
+    let(:namespace2) { 'db.coll2' }
+    let(:namespace3) { 'db.coll3' }
+    let(:selector) { { field: 'value' } }
+
+    before do
+      Mongo::QueryCache.set(caching_cursor, namespace: namespace1, selector: selector)
+      Mongo::QueryCache.set(caching_cursor, namespace: namespace2, selector: selector)
+      Mongo::QueryCache.set(caching_cursor, namespace: namespace3, selector: selector, multi_collection: true)
+    end
+
+    it 'returns nil' do
+      expect(Mongo::QueryCache.clear_namespace(namespace1)).to be_nil
+    end
+
+    it 'clears the specified namespace in the query cache' do
+      Mongo::QueryCache.clear_namespace(namespace1)
+      expect(Mongo::QueryCache.send(:cache_table)[namespace1]).to be_nil
+    end
+
+    it 'does not clear other namespaces in the query cache' do
+      Mongo::QueryCache.clear_namespace(namespace1)
+      expect(Mongo::QueryCache.send(:cache_table)[namespace2]).not_to be_nil
+    end
+
+    it 'clears the nil namespace' do
+      Mongo::QueryCache.clear_namespace(namespace1)
+      expect(Mongo::QueryCache.send(:cache_table)[nil]).to be_nil
+    end
+  end
+end

data/spec/mongo/server/app_metadata_shared.rb

@@ -8,40 +8,14 @@ shared_examples 'app metadata document' do
     document[:client][:driver][:version].should == Mongo::VERSION
   end
 
-  context 'linux' do
-    before(:all) do
-      unless SpecConfig.instance.linux?
-        skip "Linux required, we have #{RbConfig::CONFIG['host_os']}"
-      end
-    end
-
-    it 'includes operating system information' do
-      document[:client][:os][:type].should == 'linux'
-      if BSON::Environment.jruby? || RUBY_VERSION >= '3.0'
-        document[:client][:os][:name].should == 'linux'
-      else
-        document[:client][:os][:name].should == 'linux-gnu'
-      end
-      document[:client][:os][:architecture].should == 'x86_64'
-    end
-  end
-
-  context 'macos' do
-    before(:all) do
-      unless SpecConfig.instance.macos?
-        skip "MacOS required, we have #{RbConfig::CONFIG['host_os']}"
-      end
-    end
-
-    it 'includes operating system information' do
-      document[:client][:os][:type].should == 'darwin'
-      if BSON::Environment.jruby?
-        document[:client][:os][:name].should == 'darwin'
-      else
-        document[:client][:os][:name].should =~ /darwin\d+/
-      end
-      document[:client][:os][:architecture].should == 'x86_64'
+  it 'includes operating system information' do
+    document[:client][:os][:type].should == 'linux'
+    if BSON::Environment.jruby?
+      document[:client][:os][:name].should == 'linux'
+    else
+      document[:client][:os][:name].should == 'linux-gnu'
     end
+    document[:client][:os][:architecture].should == 'x86_64'
   end
 
   context 'mri' do

data/spec/mongo/server/connection_pool_spec.rb

@@ -5,9 +5,13 @@ describe Mongo::Server::ConnectionPool do
   let(:options) { {} }
 
   let(:server_options) do
-    SpecConfig.instance.ssl_options.merge(SpecConfig.instance.compressor_options)
-      .merge(SpecConfig.instance.retry_writes_options).merge(SpecConfig.instance.auth_options)
-      .merge(options)
+    Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+      SpecConfig.instance.all_test_options,
+    )).tap do |opts|
+      opts.delete(:min_pool_size)
+      opts.delete(:max_pool_size)
+      opts.delete(:wait_queue_timeout)
+    end.update(options)
   end
 
   let(:address) do

data/spec/mongo/server/connection_spec.rb

@@ -158,6 +158,8 @@ describe Mongo::Server::Connection do
       end
 
       shared_examples_for 'logs a warning' do
+        require_warning_clean
+
         it 'logs a warning' do
           messages = []
           expect(Mongo::Logger.logger).to receive(:warn) do |msg|
@@ -172,6 +174,8 @@ describe Mongo::Server::Connection do
       end
 
       shared_examples_for 'adds server diagnostics' do
+        require_warning_clean
+
         it 'adds server diagnostics' do
           messages = []
           expect(Mongo::Logger.logger).to receive(:warn) do |msg|
@@ -248,8 +252,9 @@ describe Mongo::Server::Connection do
         require_auth
 
         let(:server_options) do
-          SpecConfig.instance.test_options.merge(monitoring_io: false).
-            merge(SpecConfig.instance.auth_options)
+          Mongo::Client.canonicalize_ruby_options(
+            SpecConfig.instance.all_test_options,
+          ).update(monitoring_io: false)
         end
 
         let(:exception) do
@@ -589,10 +594,12 @@ describe Mongo::Server::Connection do
         server,
         SpecConfig.instance.test_options.merge(
           :database => SpecConfig.instance.test_user.database,
-        ).merge(SpecConfig.instance.credentials_or_external_user(
-          user: SpecConfig.instance.test_user.name,
-          password: SpecConfig.instance.test_user.password,
-        ))
+        ).merge(Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+          SpecConfig.instance.credentials_or_external_user(
+            user: SpecConfig.instance.test_user.name,
+            password: SpecConfig.instance.test_user.password,
+          ),
+        )))
       ).tap do |connection|
         connection.connect!
       end
@@ -1099,7 +1106,7 @@ describe Mongo::Server::Connection do
           :user => SpecConfig.instance.test_user.name,
           :password => SpecConfig.instance.test_user.password,
           :database => SpecConfig.instance.test_db,
-          :auth_mech => :mongodb_cr
+          :auth_mech => :mongodb_cr,
         )
       end
 

data/spec/mongo/server_selector/secondary_preferred_spec.rb

@@ -78,8 +78,8 @@ describe Mongo::ServerSelector::SecondaryPreferred do
 
     context 'tag sets not provided' do
 
-      it 'returns secondaryPreferred' do
-        selector.to_mongos.should == {mode: 'secondaryPreferred'}
+      it 'returns nil' do
+        expect(selector.to_mongos).to be_nil
       end
     end
 
@@ -89,8 +89,8 @@ describe Mongo::ServerSelector::SecondaryPreferred do
         { :mode => 'secondaryPreferred' }
       end
 
-      it 'returns secondaryPreferred' do
-        selector.to_mongos.should == {mode: 'secondaryPreferred'}
+      it 'returns nil' do
+        expect(selector.to_mongos).to be_nil
       end
     end
 
@@ -120,8 +120,8 @@ describe Mongo::ServerSelector::SecondaryPreferred do
     context 'hedge not provided' do
       let(:hedge) { nil }
 
-      it 'returns secondaryPreferred' do
-        selector.to_mongos.should == {mode: 'secondaryPreferred'}
+      it 'returns nil' do
+        expect(selector.to_mongos).to be_nil
       end
     end
 

data/spec/mongo/socket/ssl_spec.rb

@@ -246,7 +246,7 @@ describe Mongo::Socket::SSL, retry: 3 do
         it 'raises an error' do
           lambda do
             socket
-          end.should raise_error(Mongo::Error::SocketError, /SSL handshake failed due to a hostname mismatch/)
+          end.should raise_error(Mongo::Error::SocketError, /TLS handshake failed due to a hostname mismatch/)
         end
       end
 

data/spec/mongo/socket_spec.rb

@@ -48,7 +48,7 @@ describe Mongo::Socket do
         socket.send(:map_exceptions) do
           raise OpenSSL::SSL::SSLError.new('Test error')
         end
-      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with SSL support)')
+      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with TLS support)')
     end
   end
 

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -567,8 +567,8 @@ describe Mongo::URI::SRVProtocol do
               'readPreference=secondary&maxStalenessSeconds=89'
             end
 
-            it 'does not raise an exception until the read preference is used' do
-              expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary, max_staleness: 89))
+            it 'does not raise an exception and is omitted' do
+              expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary))
             end
           end
         end
@@ -715,83 +715,114 @@ describe Mongo::URI::SRVProtocol do
         end
       end
 
+      # This context exactly duplicates the same one in uri_spec.rb
       context 'auth mechanism properties provided' do
 
+        shared_examples 'sets options in the expected manner' do
+          it 'preserves case in auth mechanism properties returned from URI' do
+            expect(uri.uri_options[:auth_mech_properties]).to eq(expected_uri_options)
+          end
+
+          it 'downcases auth mechanism properties keys in client options' do
+            client = new_local_client_nmio(string)
+            expect(client.options[:auth_mech_properties]).to eq(expected_client_options)
+          end
+        end
+
         context 'service_name' do
           let(:options) do
-            "authMechanismProperties=SERVICE_NAME:#{service_name}"
+            "authMechanismProperties=SERVICE_name:#{service_name}"
           end
 
           let(:service_name) { 'foo' }
-          let(:expected) { Mongo::Options::Redacted.new({ service_name: service_name }) }
 
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              SERVICE_name: service_name,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              service_name: service_name,
+            )
           end
+
+          include_examples 'sets options in the expected manner'
         end
 
         context 'canonicalize_host_name' do
           let(:options) do
-            "authMechanismProperties=CANONICALIZE_HOST_NAME:#{canonicalize_host_name}"
+            "authMechanismProperties=CANONICALIZE_HOST_name:#{canonicalize_host_name}"
           end
+
           let(:canonicalize_host_name) { 'true' }
-          let(:expected) { Mongo::Options::Redacted.new({ canonicalize_host_name: true }) }
 
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              CANONICALIZE_HOST_name: true,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              canonicalize_host_name: true,
+            )
           end
+
+          include_examples 'sets options in the expected manner'
         end
 
         context 'service_realm' do
           let(:options) do
-            "authMechanismProperties=SERVICE_REALM:#{service_realm}"
+            "authMechanismProperties=SERVICE_realm:#{service_realm}"
           end
 
           let(:service_realm) { 'dumdum' }
-          let(:expected) { Mongo::Options::Redacted.new({ service_realm: service_realm }) }
 
-
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              SERVICE_realm: service_realm,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              service_realm: service_realm,
+            )
           end
+
+          include_examples 'sets options in the expected manner'
         end
 
         context 'multiple properties' do
           let(:options) do
-            "authMechanismProperties=SERVICE_REALM:#{service_realm}," +
-                "CANONICALIZE_HOST_NAME:#{canonicalize_host_name}," +
-                "SERVICE_NAME:#{service_name}"
+            "authMechanismProperties=SERVICE_realm:#{service_realm}," +
+              "CANONICALIZE_HOST_name:#{canonicalize_host_name}," +
+              "SERVICE_name:#{service_name}"
           end
 
           let(:service_name) { 'foo' }
           let(:canonicalize_host_name) { 'true' }
           let(:service_realm) { 'dumdum' }
 
-          let(:expected) do
-            Mongo::Options::Redacted.new({ service_name: service_name,
-                                           canonicalize_host_name: true,
-                                           service_realm: service_realm })
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              SERVICE_name: service_name,
+              CANONICALIZE_HOST_name: true,
+              SERVICE_realm: service_realm,
+            )
           end
 
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              service_name: service_name,
+              canonicalize_host_name: true,
+              service_realm: service_realm,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
-          end
+          include_examples 'sets options in the expected manner'
         end
       end