mongo 2.12.4 → 2.14.0.rc1

data/spec/integration/transactions_api_examples_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'Transactions API examples' do
+  require_wired_tiger
+  require_transaction_support
+
+  # Until https://jira.mongodb.org/browse/RUBY-1768 is implemented, limit
+  # the tests to simple configurations
+  require_no_auth
+  require_no_tls
+
+  let(:uri_string) do
+    "mongodb://#{SpecConfig.instance.addresses.join(',')}"
+  end
+
+  it 'with_transaction API example 1' do
+
+    # Start Transactions withTxn API Example 1
+
+    # For a replica set, include the replica set name and a seedlist of the members in the URI string; e.g.
+    # uriString = 'mongodb://mongodb0.example.com:27017,mongodb1.example.com:27017/?replicaSet=myRepl'
+    # For a sharded cluster, connect to the mongos instances; e.g.
+    # uri_string = 'mongodb://mongos0.example.com:27017,mongos1.example.com:27017/'
+
+    client = Mongo::Client.new(uri_string, write_concern: {w: :majority, wtimeout: 1000})
+
+    # Prereq: Create collections.
+
+    client.use('mydb1')['foo'].insert_one(abc: 0)
+    client.use('mydb2')['bar'].insert_one(xyz: 0)
+
+    # Step 1: Define the callback that specifies the sequence of operations to perform inside the transactions.
+
+    callback = Proc.new do |my_session|
+      collection_one = client.use('mydb1')['foo']
+      collection_two = client.use('mydb2')['bar']
+
+      # Important: You must pass the session to the operations.
+
+      collection_one.insert_one({'abc': 1}, session: my_session)
+      collection_two.insert_one({'xyz': 999}, session: my_session)
+    end
+
+    #. Step 2: Start a client session.
+
+    session = client.start_session
+
+    # Step 3: Use with_transaction to start a transaction, execute the callback, and commit (or abort on error).
+
+    session.with_transaction(
+      read_concern: {level: :local},
+      write_concern: {w: :majority, wtimeout: 1000},
+      read: {mode: :primary},
+      &callback)
+
+    # End Transactions withTxn API Example 1
+
+  end
+end

data/spec/integration/transactions_examples_spec.rb

@@ -183,7 +183,8 @@ describe 'Transactions examples' do
         events_coll = session.client.use(:reporting)[:events]
 
         session.start_transaction(read_concern: { level: :snapshot },
-                                  write_concern: { w: :majority })
+                                  write_concern: { w: :majority },
+                                  read: {mode: :primary})
         employees_coll.update_one({ employee: 3 }, { '$set' => { status: 'Inactive'} },
                                   session: session)
         events_coll.insert_one({ employee: 3, status: { new: 'Inactive', old: 'Active' } },
@@ -194,7 +195,9 @@ describe 'Transactions examples' do
       session = client.start_session
 
       begin
-        run_transaction_with_retry(session) { |s| update_employee_info(s) }
+        run_transaction_with_retry(session) do
+          update_employee_info(session)
+        end
       rescue StandardError => e
         # Do something with error
         raise

data/spec/integration/x509_auth_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+# These tests assume the server was started with the certificates in
+# spec/support/certificates, and has the user that Evergreen scripts create
+# corresponding to the client certificate.
+describe 'X.509 auth integration tests' do
+  require_x509_auth
+
+  let(:authenticated_user_info) do
+    # https://stackoverflow.com/questions/21414608/mongodb-show-current-user
+    info = client.database.command(connectionStatus: 1).documents.first
+    info[:authInfo][:authenticatedUsers].first
+  end
+
+  let(:authenticated_user_name) { authenticated_user_info[:user] }
+
+  let(:client) do
+    new_local_client(SpecConfig.instance.addresses, client_options)
+  end
+
+  let(:base_client_options) { SpecConfig.instance.ssl_options }
+
+  context 'when auth not specified' do
+    let(:client_options) do
+      base_client_options
+    end
+
+    it 'does not authenticate' do
+      authenticated_user_info.should be nil
+    end
+  end
+
+  context 'certificate matching a defined user' do
+    let(:common_name) do
+      "C=US,ST=New York,L=New York City,O=MongoDB,OU=x509,CN=localhost".freeze
+    end
+
+    let(:subscriber) { EventSubscriber.new }
+
+    shared_examples 'authenticates successfully' do
+      it 'authenticates successfully' do
+        authenticated_user_name.should == common_name
+      end
+
+      let(:commands) do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        authenticated_user_name
+        commands = subscriber.started_events.map(&:command_name)
+      end
+
+      context 'server 4.2 and lower' do
+        max_server_version '4.2'
+
+        it 'uses the authenticate command to authenticate' do
+          commands.should == %w(authenticate connectionStatus)
+        end
+      end
+
+      context 'server 4.4 and higher' do
+        min_server_fcv '4.4'
+
+        it 'uses speculative authentication in ismaster to authenticate' do
+          commands.should == %w(connectionStatus)
+        end
+      end
+    end
+
+    context 'when user name is not explicitly provided' do
+      let(:client_options) do
+        base_client_options.merge(auth_mech: :mongodb_x509)
+      end
+
+      it_behaves_like 'authenticates successfully'
+    end
+
+    context 'when user name is explicitly provided and matches certificate common name' do
+      let(:client_options) do
+        base_client_options.merge(auth_mech: :mongodb_x509, user: common_name)
+      end
+
+      it_behaves_like 'authenticates successfully'
+    end
+
+    context 'when user name is explicitly provided and does not match certificate common name' do
+      let(:client_options) do
+        base_client_options.merge(auth_mech: :mongodb_x509, user: 'OU=world,CN=hello')
+      end
+
+      it 'fails to authenticate' do
+        lambda do
+          authenticated_user_name
+        end.should raise_error(Mongo::Auth::Unauthorized, /Client certificate.*is not authorized/)
+      end
+
+      # This test applies to both pre-4.4 and 4.4+.
+      # When speculative authentication fails, the response is indistinguishable
+      # from that of a server that does not support speculative authentication,
+      # and we will try to authenticate as a separate command.
+      it 'uses the authenticate command to authenticate' do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        lambda do
+          authenticated_user_name
+        end.should raise_error(Mongo::Auth::Unauthorized, /Client certificate.*is not authorized/)
+        commands = subscriber.started_events.map(&:command_name)
+        commands.should == %w(authenticate)
+      end
+    end
+  end
+end

data/spec/kerberos/kerberos_spec.rb

@@ -18,19 +18,23 @@ describe 'kerberos authentication' do
   end
 
   let(:user) do
-   "#{require_env_value('SASL_USER')}%40#{require_env_value('SASL_HOST').upcase}"
+   "#{require_env_value('SASL_USER')}%40#{realm}"
   end
 
   let(:host) do
-    "#{require_env_value('SASL_HOST')}"
+    require_env_value('SASL_HOST')
+  end
+
+  let(:realm) do
+    require_env_value('SASL_REALM')
   end
 
   let(:kerberos_db) do
-    "#{require_env_value('KERBEROS_DB')}"
+    require_env_value('KERBEROS_DB')
   end
 
   let(:auth_source) do
-    "#{require_env_value('SASL_DB')}"
+    require_env_value('SASL_DB')
   end
 
   let(:uri) do
@@ -56,7 +60,7 @@ describe 'kerberos authentication' do
 
   context 'when host is lowercased' do
     let(:host) do
-      "#{require_env_value('SASL_HOST').downcase}"
+      require_env_value('SASL_HOST').downcase
     end
 
     it_behaves_like 'correctly authenticates'
@@ -64,7 +68,7 @@ describe 'kerberos authentication' do
 
   context 'when host is uppercased' do
     let(:host) do
-      "#{require_env_value('SASL_HOST').upcase}"
+      require_env_value('SASL_HOST').upcase
     end
 
     it_behaves_like 'correctly authenticates'

data/spec/lite_spec_helper.rb

@@ -4,8 +4,6 @@ CURRENT_PATH = File.expand_path(File.dirname(__FILE__))
 SERVER_DISCOVERY_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam/**/*.yml").sort
 SDAM_MONITORING_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam_monitoring/*.yml").sort
 SERVER_SELECTION_RTT_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection_rtt/*.yml").sort
-SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection/**/*.yml").sort
-MAX_STALENESS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/max_staleness/**/*.yml").sort
 CRUD_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/crud/**/*.yml").sort
 CRUD2_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/crud_v2/**/*.yml").sort
 RETRYABLE_WRITES_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/retryable_writes/**/*.yml").sort
@@ -22,7 +20,13 @@ CMAP_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/cmap/*.yml").sort
 AUTH_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/auth/*.yml").sort
 CLIENT_SIDE_ENCRYPTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/client_side_encryption/*.yml").sort
 
-unless ENV['CI']
+# Disable output buffering: https://www.rubyguides.com/2019/02/ruby-io/
+STDOUT.sync = true
+STDERR.sync = true
+
+if %w(1 true yes).include?(ENV['CI']&.downcase)
+  autoload :Byebug, 'byebug'
+else
   # Load debuggers before loading the driver code, so that breakpoints
   # can be placed in the driver code on file/class level.
   begin
@@ -35,9 +39,17 @@ end
 require 'mongo'
 require 'pp'
 
+if BSON::Environment.jruby?
+  # Autoloading appears to not work in some environments without these
+  # gem calls. May have to do with rubygems version?
+  gem 'ice_nine'
+  gem 'timecop'
+end
+
 autoload :Benchmark, 'benchmark'
 autoload :IceNine, 'ice_nine'
 autoload :Timecop, 'timecop'
+autoload :ChildProcess, 'childprocess'
 
 if BSON::Environment.jruby?
   require 'concurrent-ruby'
@@ -49,7 +61,7 @@ end
 require 'support/utils'
 require 'support/spec_config'
 
-Mongo::Logger.logger = Logger.new($stdout)
+Mongo::Logger.logger = Logger.new(STDOUT)
 unless SpecConfig.instance.client_debug?
   Mongo::Logger.logger.level = Logger::INFO
 end
@@ -65,20 +77,7 @@ require 'support/crypt'
 require 'support/json_ext_formatter'
 require 'support/sdam_formatter_integration'
 require 'support/background_thread_registry'
-
-require 'runners/server_discovery_and_monitoring'
-require 'runners/server_selection_rtt'
-require 'runners/server_selection'
-require 'runners/sdam_monitoring'
-require 'runners/crud'
-require 'runners/command_monitoring'
-require 'runners/cmap'
-require 'runners/connection_string'
-require 'runners/connection_string'
-require 'runners/gridfs'
-require 'runners/transactions'
-require 'runners/change_streams'
-require 'runners/auth'
+require 'support/session_registry'
 
 if SpecConfig.instance.mri?
   require 'timeout_interrupt'
@@ -112,17 +111,27 @@ RSpec.configure do |config|
     # Tests should take under 10 seconds ideally but it seems
     # we have some that run for more than 10 seconds in CI.
     config.around(:each) do |example|
-      TimeoutInterrupt.timeout(45) do
+      timeout = if %w(1 true yes).include?(ENV['STRESS']&.downcase)
+        210
+      else
+        45
+      end
+      TimeoutInterrupt.timeout(timeout) do
         example.run
       end
     end
   end
 
   if SpecConfig.instance.ci?
-    unless BSON::Environment.jruby?
-      if defined?(Rfc)
+    if defined?(Rfc::Rif)
+      unless BSON::Environment.jruby?
         Rfc::Rif.output_object_space_stats = true
       end
+
+      # Uncomment this line to log memory and CPU statistics during
+      # test suite execution to diagnose issues potentially related to
+      # system resource exhaustion.
+      #Rfc::Rif.output_system_load = true
     end
   end
 
@@ -130,9 +139,11 @@ RSpec.configure do |config|
     c.syntax = [:should, :expect]
     c.max_formatted_output_length = 10000
   end
-end
 
-EventSubscriber.initialize
+  if config.respond_to?(:fuubar_output_pending_results=)
+    config.fuubar_output_pending_results = false
+  end
+end
 
 if SpecConfig.instance.active_support?
   require "active_support/time"

data/spec/mongo/address/ipv4_spec.rb

@@ -65,7 +65,7 @@ describe Mongo::Address::IPv4 do
     context 'when ssl options are provided' do
 
       let(:socket) do
-        resolver.socket(5, :ssl => true)
+        resolver.socket(5, ssl: true)
       end
 
       it 'returns an ssl socket' do

data/spec/mongo/address_spec.rb

@@ -234,7 +234,7 @@ describe Mongo::Address do
       end
 
       let(:address) do
-        Mongo::Address.new(custom_hostname)
+        Mongo::Address.new("#{custom_hostname}:#{SpecConfig.instance.any_port}")
       end
 
       before do
@@ -277,7 +277,7 @@ describe Mongo::Address do
 
       if Socket.const_defined?(:TCP_KEEPIDLE)
         it 'sets the socket TCP_KEEPIDLE option' do
-          expect(socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPIDLE).int).to be <= 300
+          expect(socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPIDLE).int).to be <= 120
         end
       end
     end
@@ -291,7 +291,7 @@ describe Mongo::Address do
         RSpec::Mocks.with_temporary_scope do
           resolved_address = double('address')
           # This test's expectation
-          expect(resolved_address).to receive(:socket).with(0, {}, connect_timeout: 10)
+          expect(resolved_address).to receive(:socket).with(0, connect_timeout: 10)
 
           expect(Mongo::Address::IPv4).to receive(:new).and_return(resolved_address)
 

data/spec/mongo/auth/aws/request_region_spec.rb

@@ -0,0 +1,42 @@
+require 'lite_spec_helper'
+
+AWS_REGION_TEST_CASES = {
+  'sts.amazonaws.com' => 'us-east-1',
+  'sts.us-west-2.amazonaws.com' => 'us-west-2',
+  'sts.us-west-2.amazonaws.com.ch' => 'us-west-2',
+  'example.com' => 'com',
+  'localhost' => 'us-east-1',
+  'sts..com' => Mongo::Error::InvalidServerAuthHost,
+  '.amazonaws.com' => Mongo::Error::InvalidServerAuthHost,
+  'sts.amazonaws.' => Mongo::Error::InvalidServerAuthHost,
+  '' => Mongo::Error::InvalidServerAuthResponse,
+  'x' * 256 => Mongo::Error::InvalidServerAuthHost,
+}
+
+describe 'AWS auth region tests' do
+
+  AWS_REGION_TEST_CASES.each do |host, expected_region|
+    context "host '#{host}'" do
+      let(:request) do
+        Mongo::Auth::Aws::Request.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: host,
+          server_nonce: 'server_nonce',
+        )
+      end
+
+      if expected_region.is_a?(String)
+        it 'derives expected region' do
+          request.region.should == expected_region
+        end
+      else
+        it 'fails with an error' do
+          lambda do
+            request.region
+          end.should raise_error(expected_region)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/auth/aws/request_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Mongo::Auth::Aws::Request do
+
+  describe "#formatted_time" do
+    context "when time is provided and frozen" do
+      let(:original_time) { Time.at(1592399523).freeze }
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce',
+          time: original_time
+        )
+      end
+
+      it 'doesn\'t modify the time instance variable' do
+        expect { request.formatted_time }.to_not raise_error
+      end
+
+      it 'returns the correct formatted time' do
+        expect(request.formatted_time).to eq('20200617T131203Z')
+      end
+    end
+
+    context "when time is not provided" do
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce'
+        )
+      end
+
+      it 'doesn\'t raise an error on formatted_time' do
+        expect { request.formatted_time }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#signature" do
+    context "when time is provided and frozen" do
+      let(:original_time) { Time.at(1592399523).freeze }
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce',
+          time: original_time
+        )
+      end
+
+      it 'doesn\'t raise error on signature' do
+        expect { request.signature }.to_not raise_error
+      end
+    end
+
+    context "when time is not provided" do
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce'
+        )
+      end
+
+      it 'doesn\'t raise error on signature' do
+        expect { request.signature }.to_not raise_error
+      end
+    end
+  end
+end