mongo 2.13.1 → 2.14.0.rc1

data/spec/mongo/crypt/auto_encryption_context_spec.rb

@@ -93,7 +93,7 @@ describe Mongo::Crypt::AutoEncryptionContext do
       end
 
       let(:logger) do
-        ::Logger.new($stdout).tap do |logger|
+        ::Logger.new(STDOUT).tap do |logger|
           logger.level = ::Logger::DEBUG
         end
       end

data/spec/mongo/crypt/explicit_decryption_context_spec.rb

@@ -57,7 +57,7 @@ describe Mongo::Crypt::ExplicitDecryptionContext do
       end
 
       let(:logger) do
-        ::Logger.new($stdout).tap do |logger|
+        ::Logger.new(STDOUT).tap do |logger|
           logger.level = ::Logger::DEBUG
         end
       end

data/spec/mongo/crypt/explicit_encryption_context_spec.rb

@@ -153,7 +153,7 @@ describe Mongo::Crypt::ExplicitEncryptionContext do
 
       let(:key_alt_name) { nil }
       let(:logger) do
-        ::Logger.new($stdout).tap do |logger|
+        ::Logger.new(STDOUT).tap do |logger|
           logger.level = ::Logger::DEBUG
         end
       end

data/spec/mongo/database_spec.rb

@@ -825,6 +825,50 @@ describe Mongo::Database do
         end
       end
 
+      context 'when write concern is passed in as an option' do
+        min_server_fcv '3.4'
+        require_topology :single
+
+        let(:client_options) do
+          {
+            write_concern: {w: 0},
+            database: :test
+          }
+        end
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:subscriber) { EventSubscriber.new }
+
+        let(:client) do
+          root_authorized_client.tap do |client|
+            client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+          end.with(client_options)
+        end
+
+        let(:events) do
+          subscriber.command_started_events('dropDatabase')
+        end
+
+        let(:database_test_wc) do
+          client.database
+        end
+
+        let!(:command) do
+          Utils.get_command_event(client, 'dropDatabase') do |client|
+            database_test_wc.drop({ write_concern: {w: 'majority'} })
+          end.command
+        end
+
+        it 'applies the write concern passed in as an option' do
+          expect(events.length).to eq(1)
+          expect(command).to_not be_nil
+          expect(command[:writeConcern][:w]).to eq('majority')
+        end
+      end
+
       context 'when the server does not support write concern on the dropDatabase command' do
         max_server_version '3.2'
 

data/spec/mongo/error/no_server_available_spec.rb

@@ -16,7 +16,7 @@ describe Mongo::Error::NoServerAvailable do
     end
 
     it 'is correct' do
-      expect(error.message).to eq('No primary server is available in cluster: #<Cluster topology=Unknown[127.0.0.1:27017] servers=[#<Server address=127.0.0.1:27017 UNKNOWN>]> with timeout=30, LT=0.015')
+      expect(error.message).to eq('No primary server is available in cluster: #<Cluster topology=Unknown[127.0.0.1:27017] servers=[#<Server address=127.0.0.1:27017 UNKNOWN NO-MONITORING>]> with timeout=30, LT=0.015')
     end
 
     context 'when cluster is nil' do

data/spec/mongo/logger_spec.rb

@@ -6,6 +6,16 @@ describe Mongo::Logger do
     described_class.logger
   end
 
+  around do |example|
+    saved_logger = Mongo::Logger.logger
+
+    begin
+      example.run
+    ensure
+      Mongo::Logger.logger = saved_logger
+    end
+  end
+
   describe '.logger' do
 
     context 'when no logger has been set' do
@@ -18,25 +28,21 @@ describe Mongo::Logger do
         Mongo::Logger.logger = nil
       end
 
-      after do
-        Mongo::Logger.logger = test_logger
-      end
-
       it 'returns the default logger' do
-        expect(logger.level).to eq(Logger::DEBUG)
+        expect(logger.level).to eq(Logger::INFO)
       end
     end
 
     context 'when a logger has been set' do
 
       let(:info) do
-        Logger.new($stdout).tap do |log|
+        Logger.new(STDOUT).tap do |log|
           log.level = Logger::INFO
         end
       end
 
       let(:debug) do
-        Logger.new($stdout).tap do |log|
+        Logger.new(STDOUT).tap do |log|
           log.level = Logger::DEBUG
         end
       end
@@ -45,10 +51,6 @@ describe Mongo::Logger do
         described_class.logger = debug
       end
 
-      after do
-        described_class.logger = info
-      end
-
       it 'returns the provided logger' do
         expect(logger.level).to eq(Logger::DEBUG)
       end

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/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