mongo 2.13.2 → 2.14.0.rc1

data/spec/mongo/crypt/auto_decryption_context_spec.rb

@@ -76,7 +76,7 @@ describe Mongo::Crypt::AutoDecryptionContext 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/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/data_key_context_spec.rb

@@ -188,7 +188,7 @@ describe Mongo::Crypt::DataKeyContext do
       end
 
       context 'with valid endpoint' do
-        let(:options) { { master_key: { region: 'us-east-2', key: 'arn', endpoint: 'kms.us-east-2.amazonaws.com:443' } } }
+        let(:options) { { master_key: { region: 'us-east-2', key: 'arn', endpoint: 'endpoint/to/kms' } } }
 
         it 'does not raise an exception' do
           expect do

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

@@ -2,19 +2,6 @@ require 'spec_helper'
 
 describe Mongo::Database do
 
-  shared_context 'more than 100 collections' do
-    let(:client) do
-      root_authorized_client.use('many-collections')
-    end
-
-    before do
-      120.times do |i|
-        client["coll-#{i}"].drop
-        client["coll-#{i}"].create
-      end
-    end
-  end
-
   describe '#==' do
 
     let(:database) do
@@ -241,20 +228,6 @@ describe Mongo::Database do
         end
       end
     end
-
-    context 'when there are more than 100 collections' do
-      include_context 'more than 100 collections'
-
-      let(:collection_names) do
-        client.database.collection_names.sort
-      end
-
-      it 'lists all collections' do
-        collection_names.length.should == 120
-        collection_names.should include('coll-0')
-        collection_names.should include('coll-119')
-      end
-    end
   end
 
   describe '#list_collections' do
@@ -418,25 +391,6 @@ describe Mongo::Database do
         end
       end
     end
-
-    context 'when there are more than 100 collections' do
-      include_context 'more than 100 collections'
-
-      let(:collections) do
-        client.database.list_collections
-      end
-
-      let(:collection_names) do
-        # 2.6 server prefixes collection names with database name
-        collections.map { |info| info['name'].sub(/^many-collections\./, '') }.sort
-      end
-
-      it 'lists all collections' do
-        collections.length.should == 120
-        collection_names.should include('coll-0')
-        collection_names.should include('coll-119')
-      end
-    end
   end
 
   describe '#collections' do
@@ -587,24 +541,6 @@ describe Mongo::Database do
         end
       end
     end
-
-    context 'when there are more than 100 collections' do
-      include_context 'more than 100 collections'
-
-      let(:collections) do
-        client.database.collections
-      end
-
-      let(:collection_names) do
-        collections.map(&:name).sort
-      end
-
-      it 'lists all collections' do
-        collections.length.should == 120
-        collection_names.should include('coll-0')
-        collection_names.should include('coll-119')
-      end
-    end
   end
 
   describe '#command' do
@@ -889,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