mongo 2.13.2 → 2.15.0

data/spec/integration/crud_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'CRUD operations' do
@@ -33,6 +36,34 @@ describe 'CRUD operations' do
         end
       end
     end
+
+    context 'when using the legacy $query syntax' do
+      before do
+        collection.insert_one(_id: 1, test: 1)
+        collection.insert_one(_id: 2, test: 2)
+        collection.insert_one(_id: 3, test: 3)
+      end
+
+      context 'filter only' do
+        it 'passes the filter' do
+          collection.find(:'$query' => {test: 1}).first.should == {'_id' => 1, 'test' => 1}
+        end
+      end
+
+      context 'empty filter with order' do
+        it 'passes the filter' do
+          collection.find(:'$query' => {}, :'$orderby' => {test: 1}).first.should == {'_id' => 1, 'test' => 1}
+          collection.find(:'$query' => {}, :'$orderby' => {test: -1}).first.should == {'_id' => 3, 'test' => 3}
+        end
+      end
+
+      context 'filter with order' do
+        it 'passes both filter and order' do
+          collection.find(:'$query' => {test: {'$gt' => 1}}, '$orderby' => {test: 1}).first.should == {'_id' => 2, 'test' => 2}
+          collection.find(:'$query' => {test: {'$gt' => 1}}, '$orderby' => {test: -1}).first.should == {'_id' => 3, 'test' => 3}
+        end
+      end
+    end
   end
 
   describe 'insert' do

data/spec/integration/cursor_reaping_spec.rb

@@ -1,9 +1,22 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Cursor reaping' do
   # JRuby does reap cursors but GC.start does not force GC to run like it does
   # in MRI, I don't currently know how to force GC to run in JRuby
-  only_mri
+  require_mri
+
+  around(:all) do |example|
+    saved_level = Mongo::Logger.logger.level
+    Mongo::Logger.logger.level = Logger::DEBUG
+    begin
+      example.run
+    ensure
+      Mongo::Logger.logger.level = saved_level
+    end
+  end
 
   let(:subscriber) { EventSubscriber.new }
 
@@ -37,37 +50,63 @@ describe 'Cursor reaping' do
       expect(events).to be_empty
     end
 
+    def abandon_cursors
+      [].tap do |cursor_ids|
+        # scopes are weird, having this result in a let block
+        # makes it not garbage collected
+        10.times do
+          scope = collection.find.batch_size(2).no_cursor_timeout
+
+          # there is no API for retrieving the cursor
+          scope.each.first
+          # and keep the first cursor
+          cursor_ids << scope.instance_variable_get('@cursor').id
+        end
+      end
+    end
+
     # this let block is a kludge to avoid copy pasting all of this code
     let(:cursor_id_and_kill_event) do
       expect(Mongo::Operation::KillCursors).to receive(:new).at_least(:once).and_call_original
 
-      cursor_id = nil
-
-      # scopes are weird, having this result in a let block
-      # makes it not garbage collected
-      2.times do
-        scope = collection.find.batch_size(2).no_cursor_timeout
+      cursor_ids = abandon_cursors
 
-        # there is no API for retrieving the cursor
-        scope.each.first
-        # and keep the first cursor
-        cursor_id ||= scope.instance_variable_get('@cursor').id
+      cursor_ids.each do |cursor_id|
+        expect(cursor_id).to be_a(Integer)
+        expect(cursor_id > 0).to be true
       end
 
-      expect(cursor_id).to be_a(Integer)
-      expect(cursor_id > 0).to be true
-
       GC.start
+      sleep 1
 
       # force periodic executor to run because its frequency is not configurable
       client.cluster.instance_variable_get('@periodic_executor').execute
 
       started_event = subscriber.started_events.detect do |event|
-        event.command['killCursors'] &&
-        event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
+        event.command['killCursors']
+      end
+      started_event.should_not be nil
+
+      found_cursor_id = nil
+      started_event = subscriber.started_events.detect do |event|
+        found = false
+        if event.command['killCursors']
+          cursor_ids.each do |cursor_id|
+            if event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
+              found_cursor_id = cursor_id
+              found = true
+              break
+            end
+          end
+        end
+        found
+      end
+
+      if started_event.nil?
+        p subscriber.started_events
       end
 
-      expect(started_event).not_to be_nil
+      started_event.should_not be nil
 
       succeeded_event = subscriber.succeeded_events.detect do |event|
         event.command_name == 'killCursors' && event.request_id == started_event.request_id
@@ -77,7 +116,7 @@ describe 'Cursor reaping' do
 
       expect(succeeded_event.reply['ok']).to eq 1
 
-      [cursor_id, succeeded_event]
+      [found_cursor_id, succeeded_event]
     end
 
     it 'is reaped' do

data/spec/integration/docs_examples_spec.rb

@@ -1,10 +1,20 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'aggregation examples in Ruby' do
   before(:all) do
     # In sharded clusters we need to ensure the database exists before running
     # the tests in this file.
-    ClientRegistry.instance.global_client('authorized')['_placeholder'].create
+    begin
+      ClientRegistry.instance.global_client('authorized')['_placeholder'].create
+    rescue Mongo::Error::OperationFailure => e
+      # Collection already exists
+      if e.code != 48
+        raise
+      end
+    end
   end
 
   let(:client) do

data/spec/integration/error_detection_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Error detection' do

data/spec/integration/fork_reconnect_spec.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'fork reconnect' do
   require_fork
-  only_mri
+  require_mri
 
   # On multi-shard sharded clusters a succeeding write request does not
   # guarantee that the next operation will succeed (since it could be sent to
@@ -18,7 +21,10 @@ describe 'fork reconnect' do
 
   describe 'monitoring connection' do
     let(:monitor) do
-      Mongo::Server::Monitor.new(server, [], Mongo::Monitoring.new, server.options)
+      Mongo::Server::Monitor.new(server, [], Mongo::Monitoring.new, server.options.merge(
+        app_metadata: client.cluster.monitor_app_metadata,
+        push_monitor_app_metadata: client.cluster.push_monitor_app_metadata,
+      ))
     end
 
     it 'reconnects' do
@@ -131,7 +137,7 @@ describe 'fork reconnect' do
         status.exitstatus.should == 0
       else
         Utils.wrap_forked_child do
-          client.database.command(ismaster: 1).should be_a(Mongo::Operation::Result)
+          client.database.command(ping: 1).should be_a(Mongo::Operation::Result)
         end
       end
 
@@ -139,5 +145,60 @@ describe 'fork reconnect' do
       # performed by the child is recovered from.
       client['foo'].find(test: 1)
     end
+
+    # Test from Driver Sessions Spec
+    #   * Create ClientSession
+    #   * Record its lsid
+    #   * Delete it (so the lsid is pushed into the pool)
+    #   * Fork
+    #   * In the parent, create a ClientSession and assert its lsid is the same.
+    #   * In the child, create a ClientSession and assert its lsid is different.
+    describe 'session pool' do
+      it 'is cleared after fork' do
+        session = client.get_session
+        parent_lsid = session.session_id
+        session.end_session
+        if pid = fork
+          pid, status = Process.wait2(pid)
+          status.exitstatus.should == 0
+        else
+          Utils.wrap_forked_child do
+            client.reconnect
+            child_session = client.get_session
+            child_lsid = child_session.session_id
+            expect(child_lsid).not_to eq(parent_lsid)
+          end
+        end
+
+        expect(client.get_session.session_id).to eq(parent_lsid)
+      end
+
+      # Test from Driver Sessions Spec
+      #   * Create ClientSession
+      #   * Record its lsid
+      #   * Fork
+      #   * In the parent, return the ClientSession to the pool, create a new ClientSession, and assert its lsid is the same.
+      #   * In the child, return the ClientSession to the pool, create a new ClientSession, and assert its lsid is different.
+      it 'does not return parent process sessions to child process pool' do
+        session = client.get_session
+        parent_lsid = session.session_id
+
+        if pid = fork
+          pid, status = Process.wait2(pid)
+          status.exitstatus.should == 0
+        else
+          Utils.wrap_forked_child do
+            client.reconnect
+            session.end_session
+            child_session = client.get_session
+            child_lsid = child_session.session_id
+            expect(child_lsid).not_to eq(parent_lsid)
+          end
+        end
+
+        session.end_session
+        expect(client.get_session.session_id).to eq(parent_lsid)
+      end
+    end
   end
 end

data/spec/integration/get_more_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'getMore operation' do

data/spec/integration/grid_fs_bucket_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'GridFS bucket integration' do
@@ -30,7 +33,7 @@ describe 'GridFS bucket integration' do
 
     context 'in binary encoding' do
       let(:data_to_write) do
-        data.force_encoding('binary').freeze
+        data.dup.force_encoding('binary').freeze
       end
 
       it_behaves_like 'round-trips'

data/spec/integration/heartbeat_events_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Heartbeat events' do
@@ -25,7 +28,7 @@ describe 'Heartbeat events' do
       server_selection_timeout: 0.1, connect: :direct)) }
 
   it 'notifies on successful heartbeats' do
-    client.database.command(ismaster: 1)
+    client.database.command(ping: 1)
 
     started_event = subscriber.started_events.first
     expect(started_event).not_to be nil
@@ -43,10 +46,10 @@ describe 'Heartbeat events' do
 
   it 'notifies on failed heartbeats' do
     exc = HeartbeatEventsSpecTestException.new
-    expect_any_instance_of(Mongo::Server::Monitor).to receive(:ismaster).at_least(:once).and_raise(exc)
+    expect_any_instance_of(Mongo::Server::Monitor).to receive(:check).at_least(:once).and_raise(exc)
 
     expect do
-      client.database.command(ismaster: 1)
+      client.database.command(ping: 1)
     end.to raise_error(Mongo::Error::NoServerAvailable)
 
     started_event = subscriber.started_events.first
@@ -72,7 +75,7 @@ describe 'Heartbeat events' do
 
     shared_examples_for 'does not notify on heartbeats' do
       it 'does not notify on heartbeats' do
-        client.database.command(ismaster: 1)
+        client.database.command(ping: 1)
 
         started_event = subscriber.started_events.first
         expect(started_event).to be nil

data/spec/integration/mmapv1_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 # This test is a marker used to verify that the test suite runs on

data/spec/integration/mongos_pinning_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Mongos pinning' do

data/spec/integration/ocsp_connectivity_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'lite_spec_helper'
+
+# These tests test the configurations described in
+# https://github.com/mongodb/specifications/blob/master/source/ocsp-support/tests/README.rst#integration-tests-permutations-to-be-tested
+describe 'OCSP connectivity' do
+  require_ocsp_connectivity
+  clear_ocsp_cache
+
+  let(:client) do
+    new_local_client(ENV.fetch('MONGODB_URI'),
+      server_selection_timeout: 5,
+    )
+  end
+
+  if ENV['OCSP_CONNECTIVITY'] == 'fail'
+    it 'fails to connect' do
+      lambda do
+        client.command(ping: 1)
+      end.should raise_error(Mongo::Error::NoServerAvailable, /UNKNOWN/)
+    end
+  else
+    it 'works' do
+      client.command(ping: 1)
+    end
+  end
+end

data/spec/integration/ocsp_verifier_cache_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'lite_spec_helper'
+require 'webrick'
+
+describe Mongo::Socket::OcspVerifier do
+  require_ocsp_verifier
+
+  shared_examples 'verifies' do
+    context 'mri' do
+      fails_on_jruby
+
+      it 'verifies the first time and reads from cache the second time' do
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+          verifier.verify_with_cache.should be true
+        end
+
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).not_to receive(:do_verify)
+
+          verifier.verify_with_cache.should be true
+        end
+      end
+    end
+
+    context 'jruby' do
+      require_jruby
+
+      # JRuby does not return OCSP endpoints, therefore we never perform
+      # any validation.
+      # https://github.com/jruby/jruby-openssl/issues/210
+      it 'does not verify' do
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+          verifier.verify.should be false
+        end
+
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+          verifier.verify.should be false
+        end
+      end
+    end
+  end
+
+  shared_examples 'fails verification' do
+    context 'mri' do
+      fails_on_jruby
+
+      it 'verifies the first time, reads from cache the second time, raises an exception in both cases' do
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+          lambda do
+            verifier.verify
+          # Redirect tests receive responses from port 8101,
+          # tests without redirects receive responses from port 8100.
+          end.should raise_error(Mongo::Error::ServerCertificateRevoked, %r,TLS certificate of 'foo' has been revoked according to 'http://localhost:810[01]/status',)
+        end
+
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).not_to receive(:do_verify)
+
+          lambda do
+            verifier.verify
+          # Redirect tests receive responses from port 8101,
+          # tests without redirects receive responses from port 8100.
+          end.should raise_error(Mongo::Error::ServerCertificateRevoked, %r,TLS certificate of 'foo' has been revoked according to 'http://localhost:810[01]/status',)
+        end
+      end
+    end
+
+    context 'jruby' do
+      require_jruby
+
+      # JRuby does not return OCSP endpoints, therefore we never perform
+      # any validation.
+      # https://github.com/jruby/jruby-openssl/issues/210
+      it 'does not verify' do
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+          verifier.verify.should be false
+        end
+
+        RSpec::Mocks.with_temporary_scope do
+          expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+          verifier.verify.should be false
+        end
+      end
+    end
+  end
+
+  shared_examples 'does not verify' do
+    it 'does not verify and does not raise an exception' do
+      RSpec::Mocks.with_temporary_scope do
+        expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+        verifier.verify.should be false
+      end
+
+      RSpec::Mocks.with_temporary_scope do
+        expect_any_instance_of(Mongo::Socket::OcspVerifier).to receive(:do_verify).and_call_original
+
+        verifier.verify.should be false
+      end
+    end
+  end
+
+  shared_context 'verifier' do |opts|
+    algorithm = opts[:algorithm]
+
+    let(:cert_path) { SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/server.pem") }
+    let(:ca_cert_path) { SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/ca.pem") }
+
+    let(:cert) { OpenSSL::X509::Certificate.new(File.read(cert_path)) }
+    let(:ca_cert) { OpenSSL::X509::Certificate.new(File.read(ca_cert_path)) }
+
+    let(:cert_store) do
+      OpenSSL::X509::Store.new.tap do |store|
+        store.add_cert(ca_cert)
+      end
+    end
+
+    let(:verifier) do
+      described_class.new('foo', cert, ca_cert, cert_store, timeout: 3)
+    end
+  end
+
+  include_context 'verifier', algorithm: 'rsa'
+  algorithm = 'rsa'
+
+  %w(ca delegate).each do |responder_cert|
+    responder_cert_file_name = {
+      'ca' => 'ca',
+      'delegate' => 'ocsp-responder',
+    }.fetch(responder_cert)
+
+    context "when responder uses #{responder_cert} cert" do
+      context 'good response' do
+        with_ocsp_mock(
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/ca.pem"),
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/#{responder_cert_file_name}.crt"),
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/#{responder_cert_file_name}.key"),
+        )
+
+        include_examples 'verifies'
+
+        it 'does not wait for the timeout' do
+          lambda do
+            verifier.verify
+          end.should take_shorter_than 3
+        end
+      end
+
+      context 'revoked response' do
+        with_ocsp_mock(
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/ca.pem"),
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/#{responder_cert_file_name}.crt"),
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/#{responder_cert_file_name}.key"),
+          fault: 'revoked'
+        )
+
+        include_examples 'fails verification'
+      end
+
+      context 'unknown response' do
+        with_ocsp_mock(
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/ca.pem"),
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/#{responder_cert_file_name}.crt"),
+          SpecConfig.instance.ocsp_files_dir.join("#{algorithm}/#{responder_cert_file_name}.key"),
+          fault: 'unknown',
+        )
+
+        include_examples 'does not verify'
+
+        it 'does not wait for the timeout' do
+          lambda do
+            verifier.verify
+          end.should take_shorter_than 3
+        end
+      end
+    end
+  end
+end