mongo 2.13.0.beta1 → 2.14.0

data/spec/mongo/operation/insert/op_msg_spec.rb

@@ -72,7 +72,7 @@ describe Mongo::Operation::Insert::OpMsg do
 
   describe 'write concern' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when write concern is not specified' do
 
@@ -99,7 +99,7 @@ describe Mongo::Operation::Insert::OpMsg do
 
   describe '#message' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when the server supports OP_MSG' do
       min_server_fcv '3.6'
@@ -167,7 +167,7 @@ describe Mongo::Operation::Insert::OpMsg do
 
         context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
           # Mocks on features are incompatible with linting
-          skip_if_linting
+          require_no_linting
 
           let(:expected_global_args) do
             global_args.dup.tap do |args|

data/spec/mongo/operation/read_preference_op_msg_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Mongo::Operation::SessionsSupported do
   # https://jira.mongodb.org/browse/RUBY-2224
-  skip_if_linting
+  require_no_linting
 
   let(:selector) do
     BSON::Document.new(name: 'test')

data/spec/mongo/operation/update/command_spec.rb

@@ -69,7 +69,7 @@ describe Mongo::Operation::Update::Command do
 
   describe 'write concern' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when write concern is not specified' do
 
@@ -96,7 +96,7 @@ describe Mongo::Operation::Update::Command do
 
   describe '#message' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when the server does not support OP_MSG' do
       max_server_version '3.4'

data/spec/mongo/operation/update/op_msg_spec.rb

@@ -78,7 +78,7 @@ describe Mongo::Operation::Update::OpMsg do
 
   describe 'write concern' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when write concern is not specified' do
 
@@ -105,7 +105,7 @@ describe Mongo::Operation::Update::OpMsg do
 
   describe '#message' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when the server supports OP_MSG' do
       min_server_fcv '3.6'
@@ -159,7 +159,7 @@ describe Mongo::Operation::Update::OpMsg do
 
         context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
           # Mocks on features are incompatible with linting
-          skip_if_linting
+          require_no_linting
 
           let(:expected_global_args) do
             global_args.dup.tap do |args|

data/spec/mongo/protocol/msg_spec.rb

@@ -425,6 +425,16 @@ describe Mongo::Protocol::Msg do
         expect(message.serialize).to be_a(BSON::ByteBuffer)
       end
     end
+
+    [:more_to_come, :exhaust_allowed].each do |flag|
+      context "with #{flag} flag" do
+        let(:flags) { [flag] }
+
+        it "round trips #{flag} flag" do
+          expect(deserialized.flags).to eq(flags)
+        end
+      end
+    end
   end
 
   describe '#deserialize' do

data/spec/mongo/query_cache_spec.rb

@@ -0,0 +1,280 @@
+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(result).to receive(:namespace) { 'db.coll' }
+      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/semaphore_spec.rb

@@ -0,0 +1,51 @@
+require 'lite_spec_helper'
+
+describe Mongo::Semaphore do
+  let(:semaphore) do
+    described_class.new
+  end
+
+  it 'waits until signaled' do
+    consumer = Thread.new do
+      semaphore.wait(3)
+    end
+
+    # Context switch to start the thread
+    sleep 0.1
+
+    start_time = Time.now
+    semaphore.signal
+    consumer.join
+
+    (Time.now - start_time).should < 1
+  end
+
+  it 'waits until broadcast' do
+    consumer = Thread.new do
+      semaphore.wait(3)
+    end
+
+    # Context switch to start the thread
+    sleep 0.1
+
+    start_time = Time.now
+    semaphore.broadcast
+    consumer.join
+
+    (Time.now - start_time).should < 1
+  end
+
+  it 'times out' do
+    consumer = Thread.new do
+      semaphore.wait(2)
+    end
+
+    # Context switch to start the thread
+    sleep 0.1
+
+    start_time = Time.now
+    consumer.join
+
+    (Time.now - start_time).should > 1
+  end
+end

data/spec/mongo/server/app_metadata_shared.rb

@@ -10,7 +10,7 @@ shared_examples 'app metadata document' do
 
   it 'includes operating system information' do
     document[:client][:os][:type].should == 'linux'
-    if BSON::Environment.jruby?
+    if BSON::Environment.jruby? || RUBY_VERSION >= '3.0'
       document[:client][:os][:name].should == 'linux'
     else
       document[:client][:os][:name].should == 'linux-gnu'
@@ -19,7 +19,7 @@ shared_examples 'app metadata document' do
   end
 
   context 'mri' do
-    only_mri
+    require_mri
 
     it 'includes Ruby version' do
       document[:client][:platform].should start_with("Ruby #{RUBY_VERSION}")
@@ -53,4 +53,84 @@ shared_examples 'app metadata document' do
       end
     end
   end
+
+  context 'when wrapping libraries are specified' do
+    let(:app_metadata) do
+      described_class.new(wrapping_libraries: wrapping_libraries)
+    end
+
+    context 'one' do
+      let(:wrapping_libraries) { [wrapping_library] }
+
+      context 'no fields' do
+        let(:wrapping_library) do
+          {}
+        end
+
+        it 'adds empty strings' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\z/
+        end
+      end
+
+      context 'some fields' do
+        let(:wrapping_library) do
+          {name: 'Mongoid'}
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\z/
+        end
+      end
+
+      context 'all fields' do
+        let(:wrapping_library) do
+          {name: 'Mongoid', version: '7.1.2', platform: 'OS9000'}
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|7.1.2"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|OS9000\z/
+        end
+      end
+    end
+
+    context 'two' do
+      context 'some fields' do
+        let(:wrapping_libraries) do
+          [
+            {name: 'Mongoid', version: '42'},
+            # All libraries should be specifying their versions, in theory,
+            # but test not specifying a version.
+            {version: '4.0', platform: 'OS9000'},
+          ]
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid|'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|42|4.0"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\|OS9000\z/
+        end
+      end
+
+      context 'a realistic Mongoid & Rails wrapping' do
+        let(:wrapping_libraries) do
+          [
+            {name: 'Mongoid', version: '7.1.2'},
+            {name: 'Rails', version: '6.0.3'},
+          ]
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid|Rails'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|7.1.2|6.0.3"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\|\z/
+        end
+      end
+    end
+  end
 end