mongo 2.4.1 → 2.14.0

data/spec/integration/fork_reconnect_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe 'fork reconnect' do
+  require_fork
+  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
+  # another shard with a dead connection).
+  require_no_multi_shard
+
+  # On Ruby 2.3 $?.exitstatus is sometimes nil after Process.wait returns which
+  # is not supposed to happen.
+  ruby_version_gte '2.4'
+
+  let(:client) { authorized_client }
+  let(:server) { client.cluster.next_primary }
+
+  describe 'monitoring connection' do
+    let(:monitor) do
+      Mongo::Server::Monitor.new(server, [], Mongo::Monitoring.new, server.options)
+    end
+
+    it 'reconnects' do
+      monitor.send(:do_scan).should be_a(Hash)
+
+      socket = monitor.connection.send(:socket).send(:socket)
+      (socket.is_a?(Socket) || socket.is_a?(OpenSSL::SSL::SSLSocket)).should be true
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        monitor.send(:do_scan).should be_a(Hash)
+
+        child_socket = monitor.connection.send(:socket).send(:socket)
+        # fileno of child_socket may equal to fileno of socket,
+        # as socket would've been closed first and file descriptors can be
+        # reused by the kernel.
+        child_socket.object_id.should_not == socket.object_id
+
+        # Exec so that we do not close any clients etc. in the child.
+        exec('/bin/true')
+      end
+
+      # Connection should remain serviceable in the parent.
+      # The operation here will be invoked again, since the earlier invocation
+      # was in the child process.
+      monitor.send(:do_scan).should be_a(Hash)
+
+      # The child closes the connection's socket, but this races with the
+      # parent. The parent can retain the original socket for a while.
+    end
+  end
+
+  describe 'non-monitoring connection' do
+    let(:connection) do
+      Mongo::Server::Connection.new(server, server.options)
+    end
+
+    let(:operation) do
+      connection.ping.should be true
+    end
+
+    it 'does not reconnect' do
+      connection.connect!
+
+      socket = connection.send(:socket).send(:socket)
+      (socket.is_a?(Socket) || socket.is_a?(OpenSSL::SSL::SSLSocket)).should be true
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          operation
+
+          child_socket = connection.send(:socket).send(:socket)
+          # fileno of child_socket may equal to fileno of socket,
+          # as socket would've been closed first and file descriptors can be
+          # reused by the kernel.
+          child_socket.object_id.should == socket.object_id
+        end
+      end
+
+      # The child closes the connection's socket, but this races with the
+      # parent. The parent can retain the original socket for a while.
+    end
+  end
+
+  describe 'connection pool' do
+
+    it 'creates a new connection in child' do
+      conn_id = server.with_connection do |connection|
+        connection.id
+      end
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          new_conn_id = server.with_connection do |connection|
+            connection.id
+          end
+
+          new_conn_id.should_not == conn_id
+        end
+      end
+
+      parent_conn_id = server.with_connection do |connection|
+        connection.id
+      end
+
+      parent_conn_id.should == conn_id
+    end
+  end
+
+  describe 'client' do
+    it 'works after fork' do
+      # Perform a write so that we discover the current primary.
+      # Previous test may have stepped down the server that authorized client
+      # considers the primary.
+      # In standalone deployments there are no retries, hence execute the
+      # operation twice manually.
+      client['foo'].insert_one(test: 1) rescue nil
+      client['foo'].insert_one(test: 1)
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          client.database.command(ismaster: 1).should be_a(Mongo::Operation::Result)
+        end
+      end
+
+      # Perform a read which can be retried, so that the socket close
+      # 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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'getMore operation' do
+  # https://jira.mongodb.org/browse/RUBY-1987
+  min_server_fcv '3.2'
+
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:collection) do
+    client['get_more_spec']
+  end
+
+  let(:scope) do
+    collection.find.batch_size(1).each
+  end
+
+  before do
+    collection.delete_many
+    collection.insert_one(a: 1)
+    #collection.insert_one(a: 2)
+  end
+
+  let(:get_more_command) do
+    event = subscriber.single_command_started_event('getMore')
+    event.command['getMore']
+  end
+
+  it 'sends cursor id as int64' do
+    scope.to_a
+
+    expect(get_more_command).to be_a(BSON::Int64)
+  end
+end

data/spec/integration/grid_fs_bucket_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'GridFS bucket integration' do
+  let(:fs) do
+    authorized_client.database.fs
+  end
+
+  describe 'UTF-8 string write' do
+    let(:data) { "hello\u2210" }
+
+    before do
+      data.length.should_not == data.bytesize
+    end
+
+    shared_examples 'round-trips' do
+      it 'round-trips' do
+        stream = fs.open_upload_stream('test') do |stream|
+          stream.write(data_to_write)
+        end
+
+        actual = nil
+        fs.open_download_stream(stream.file_id) do |stream|
+          actual = stream.read
+        end
+
+        actual.encoding.name.should == 'ASCII-8BIT'
+        actual.should == data.dup.force_encoding('binary')
+      end
+    end
+
+    context 'in binary encoding' do
+      let(:data_to_write) do
+        data.force_encoding('binary').freeze
+      end
+
+      it_behaves_like 'round-trips'
+    end
+
+    context 'in UTF-8 encoding' do
+      let(:data_to_write) do
+        data.encoding.name.should == 'UTF-8'
+        data.freeze
+      end
+
+      it_behaves_like 'round-trips'
+    end
+  end
+end

data/spec/integration/heartbeat_events_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe 'Heartbeat events' do
+  class HeartbeatEventsSpecTestException < StandardError; end
+
+  # 4.4 has two monitors and thus issues heartbeats multiple times
+  max_server_version '4.2'
+
+  clean_slate_for_all
+
+  let(:subscriber) { EventSubscriber.new }
+
+  before do
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+  end
+
+  after do
+    Mongo::Monitoring::Global.unsubscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+  end
+
+  let(:address_str) { ClusterConfig.instance.primary_address_str }
+
+  let(:client) { new_local_client([address_str],
+    SpecConfig.instance.all_test_options.merge(
+      server_selection_timeout: 0.1, connect: :direct)) }
+
+  it 'notifies on successful heartbeats' do
+    client.database.command(ismaster: 1)
+
+    started_event = subscriber.started_events.first
+    expect(started_event).not_to be nil
+    expect(started_event.address).to be_a(Mongo::Address)
+    expect(started_event.address.seed).to eq(address_str)
+
+    succeeded_event = subscriber.succeeded_events.first
+    expect(succeeded_event).not_to be nil
+    expect(succeeded_event.address).to be_a(Mongo::Address)
+    expect(succeeded_event.address.seed).to eq(address_str)
+
+    failed_event = subscriber.failed_events.first
+    expect(failed_event).to be nil
+  end
+
+  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 do
+      client.database.command(ismaster: 1)
+    end.to raise_error(Mongo::Error::NoServerAvailable)
+
+    started_event = subscriber.started_events.first
+    expect(started_event).not_to be nil
+    expect(started_event.address).to be_a(Mongo::Address)
+    expect(started_event.address.seed).to eq(address_str)
+
+    succeeded_event = subscriber.succeeded_events.first
+    expect(succeeded_event).to be nil
+
+    failed_event = subscriber.failed_events.first
+    expect(failed_event).not_to be nil
+    expect(failed_event.error).to be exc
+    expect(failed_event.failure).to be exc
+    expect(failed_event.address).to be_a(Mongo::Address)
+    expect(failed_event.address.seed).to eq(address_str)
+  end
+
+  context 'when monitoring option is false' do
+    let(:client) { new_local_client([address_str],
+      SpecConfig.instance.all_test_options.merge(
+        server_selection_timeout: 0.1, connect: :direct, monitoring: false)) }
+
+    shared_examples_for 'does not notify on heartbeats' do
+      it 'does not notify on heartbeats' do
+        client.database.command(ismaster: 1)
+
+        started_event = subscriber.started_events.first
+        expect(started_event).to be nil
+      end
+    end
+
+    it_behaves_like 'does not notify on heartbeats'
+
+    context 'when a subscriber is added manually' do
+      let(:client) do
+        sdam_proc = Proc.new do |client|
+          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+        end
+
+        new_local_client([address_str],
+          SpecConfig.instance.all_test_options.merge(
+            server_selection_timeout: 0.1, connect: :direct,
+            monitoring: false, sdam_proc: sdam_proc))
+      end
+
+      it_behaves_like 'does not notify on heartbeats'
+    end
+  end
+end

data/spec/integration/mmapv1_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+# This test is a marker used to verify that the test suite runs on
+# mmapv1 storage engine.
+describe 'mmapv1' do
+  require_mmapv1
+
+  context 'standalone' do
+    require_topology :single
+
+    it 'is exercised' do
+    end
+  end
+
+  context 'replica set' do
+    require_topology :replica_set
+
+    it 'is exercised' do
+    end
+  end
+
+  context 'sharded' do
+    require_topology :sharded
+
+    it 'is exercised' do
+    end
+  end
+end

data/spec/integration/mongos_pinning_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'Mongos pinning' do
+  require_topology :sharded
+  min_server_fcv '4.2'
+
+  let(:client) { authorized_client }
+  let(:collection) { client['mongos_pinning_spec'] }
+
+  before do
+    collection.create
+  end
+
+  context 'successful operations' do
+    it 'pins and unpins' do
+      session = client.start_session
+      expect(session.pinned_server).to be nil
+
+      session.start_transaction
+      expect(session.pinned_server).to be nil
+
+      primary = client.cluster.next_primary
+
+      collection.insert_one({a: 1}, session: session)
+      expect(session.pinned_server).not_to be nil
+
+      session.commit_transaction
+      expect(session.pinned_server).not_to be nil
+
+      collection.insert_one({a: 1}, session: session)
+      expect(session.pinned_server).to be nil
+    end
+  end
+end

data/spec/integration/ocsp_connectivity_spec.rb

@@ -0,0 +1,26 @@
+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,188 @@
+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