mongo 2.11.4 → 2.12.3

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/read_preference_spec.rb

@@ -482,4 +482,30 @@ describe 'Read preference' do
       end
     end
   end
+
+  context 'secondary read with direct connection' do
+    require_topology :replica_set
+
+    let(:address_str) do
+      Mongo::ServerSelector.get(mode: :secondary).
+        select_server(authorized_client.cluster).address.seed
+    end
+
+    let(:secondary_client) do
+      new_local_client([address_str],
+        SpecConfig.instance.all_test_options.merge(connect: :direct))
+    end
+
+    it 'succeeds without read preference' do
+      secondary_client['foo'].find.to_a
+    end
+
+    it 'succeeds with read preference: secondary' do
+      secondary_client['foo', {read: {mode: :secondary}}].find.to_a
+    end
+
+    it 'succeeds with read preference: primary' do
+      secondary_client['foo', {read: {mode: :primary}}].find.to_a
+    end
+  end
 end

data/spec/integration/reconnect_spec.rb

@@ -54,9 +54,7 @@ describe 'Client after reconnect' do
   context 'SRV monitor thread' do
 
     let(:uri) do
-      "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true".tap do |uri|
-        puts "Constructed URI: #{uri}"
-      end
+      "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}"
     end
 
     # Debug logging to troubleshoot failures in Evergreen
@@ -68,8 +66,8 @@ describe 'Client after reconnect' do
 
     let(:client) do
       ClientRegistry.instance.register_local_client(
-        Mongo::Client.new(uri, server_selection_timeout: 3.86,
-          logger: logger))
+        Mongo::Client.new(uri, SpecConfig.instance.ssl_options.merge(
+          server_selection_timeout: 3.86, logger: logger)))
     end
 
     let(:wait_for_discovery) do
@@ -134,7 +132,10 @@ describe 'Client after reconnect' do
 
       let(:client) do
         ClientRegistry.instance.register_local_client(
-          Mongo::Client.new(uri, server_selection_timeout: 3.89,
+          Mongo::Client.new(uri,
+            timeout: 5,
+            connect_timeout: 5,
+            server_selection_timeout: 3.89,
             resolv_options: {
               nameserver: 'localhost',
               nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],

data/spec/integration/size_limit_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe 'BSON & command size limits' do
+  let(:max_document_size) { 16*1024*1024 }
+
+  before do
+    authorized_collection.delete_many
+  end
+
+  # This test uses a large document that is significantly smaller than the
+  # size limit. It is a basic sanity check.
+  it 'allows user-provided documents to be 15MiB' do
+    document = { key: 'a' * 15*1024*1024, _id: 'foo' }
+
+    authorized_collection.insert_one(document)
+  end
+
+  # This test uses a large document that is significantly larger than the
+  # size limit. It is a basic sanity check.
+  it 'fails single write of oversized documents' do
+    document = { key: 'a' * 17*1024*1024, _id: 'foo' }
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  # This test checks our bulk write splitting when documents are not close
+  # to the limit, but where splitting is definitely required.
+  it 'allows split bulk write of medium sized documents' do
+    # 8 documents of 4 MiB each = 32 MiB total data, should be split over
+    # either 2 or 3 bulk writes depending on how well the driver splits
+    documents = []
+    1.upto(8) do |index|
+      documents << { key: 'a' * 4*1024*1024, _id: "in#{index}" }
+    end
+
+    authorized_collection.insert_many(documents)
+    authorized_collection.count_documents({}).should == 8
+  end
+
+  # This test ensures that document which are too big definitely fail insertion.
+  it 'fails bulk write of oversized documents' do
+    documents = []
+    1.upto(3) do |index|
+      documents << { key: 'a' * 17*1024*1024, _id: "in#{index}" }
+    end
+
+    lambda do
+      authorized_collection.insert_many(documents)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+    authorized_collection.count_documents({}).should == 0
+  end
+
+  it 'allows user-provided documents to be exactly 16MiB' do
+    # The document must contain the _id field, otherwise the server will
+    # add it which will increase the size of the document as persisted by
+    # the server.
+    document = { key: 'a' * (max_document_size - 28), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size)
+
+    authorized_collection.insert_one(document)
+  end
+
+  context 'on server versions >= 3.6' do
+    min_server_fcv '3.6'
+
+    it 'fails on the driver when a document larger than 16MiB is inserted' do
+      document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
+      expect(document.to_bson.length).to eq(max_document_size+1)
+
+      lambda do
+        authorized_collection.insert_one(document)
+      end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+    end
+  end
+
+  context 'on server versions <= 3.4' do
+    max_server_fcv '3.4'
+
+    it 'fails on the server when a document larger than 16MiB is inserted' do
+      document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
+      expect(document.to_bson.length).to eq(max_document_size+1)
+
+      lambda do
+        authorized_collection.insert_one(document)
+      end.should raise_error(Mongo::Error::OperationFailure, /object to insert too large/)
+    end
+  end
+
+  it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do
+    document = { key: 'a' * (max_document_size - 27 + 16*1024), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size+16*1024+1)
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  it 'allows bulk writes of multiple documents of exactly 16 MiB each' do
+    documents = []
+    1.upto(3) do |index|
+      document = { key: 'a' * (max_document_size - 28), _id: "in#{index}" }
+      expect(document.to_bson.length).to eq(max_document_size)
+      documents << document
+    end
+
+    authorized_collection.insert_many(documents)
+    authorized_collection.count_documents({}).should == 3
+  end
+end

data/spec/integration/srv_monitoring_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe 'SRV Monitoring' do
+  clean_slate_for_all
+
   context 'with SRV lookups mocked at Resolver' do
     let(:srv_result) do
       double('srv result').tap do |result|
@@ -51,7 +53,7 @@ describe 'SRV Monitoring' do
 
         expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Sharded)
 
-        expect(client.cluster.instance_variable_get('@srv_monitor')).to be_a(Mongo::Cluster::SrvMonitor)
+        expect(client.cluster.instance_variable_get('@srv_monitor')).to be_a(Mongo::Srv::Monitor)
 
         # Close the client in the test rather than allowing our post-test cleanup
         # to take care of it, since the client references test doubles.
@@ -84,18 +86,22 @@ describe 'SRV Monitoring' do
 
     let(:client) do
       new_local_client(uri,
-        server_selection_timeout: 3.16,
-        resolv_options: {
-          nameserver: 'localhost',
-          nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],
-        },
-        logger: logger,
+        SpecConfig.instance.ssl_options.merge(
+          server_selection_timeout: 3.16,
+          timeout: 8.11,
+          connect_timeout: 8.12,
+          resolv_options: {
+            nameserver: 'localhost',
+            nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],
+          },
+          logger: logger,
+        ),
       )
     end
 
     before do
       # Expedite the polling process
-      allow_any_instance_of(Mongo::Cluster::SrvMonitor).to receive(:scan_interval).and_return(1)
+      allow_any_instance_of(Mongo::Srv::Monitor).to receive(:scan_interval).and_return(1)
     end
 
     context 'sharded cluster' do
@@ -352,6 +358,8 @@ describe 'SRV Monitoring' do
           # Covers both NoPrimary and WithPrimary replica sets
           expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
 
+          # give the thread another moment to stop
+          sleep 0.1
           expect(client.cluster.srv_monitor).not_to be_running
         end
       end

data/spec/integration/zlib_compression_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Zlib compression' do
+  require_compression
+
+  before do
+    authorized_client['test'].drop
+  end
+
+  context 'when client has zlib compressor option enabled' do
+    it 'compresses the message to the server' do
+      # Double check that the client has zlib compression enabled
+      expect(authorized_client.options[:compressors]).to include('zlib')
+
+      expect(Mongo::Protocol::Compressed).to receive(:new).twice.and_call_original
+      expect(Zlib::Deflate).to receive(:deflate).twice.and_call_original
+      expect(Zlib::Inflate).to receive(:inflate).twice.and_call_original
+
+      authorized_client['test'].insert_one(_id: 1, text: 'hello world')
+      document = authorized_client['test'].find(_id: 1).first
+
+      expect(document['text']).to eq('hello world')
+    end
+  end
+end

data/spec/kerberos/kerberos_spec.rb

@@ -0,0 +1,87 @@
+require 'lite_spec_helper'
+
+describe 'kerberos authentication' do
+  require_mongo_kerberos
+
+  before(:all) do
+    unless %w(1 yes true).include?(ENV['MONGO_RUBY_DRIVER_KERBEROS_INTEGRATION']&.downcase)
+      skip "Set MONGO_RUBY_DRIVER_KERBEROS_INTEGRATION=1 in environment to run the Kerberos integration tests"
+    end
+  end
+
+  def require_env_value(key)
+    ENV[key].tap do |value|
+      if value.nil? || value.empty?
+        raise "Value for key #{key} is not present in environment as required"
+      end
+    end
+  end
+
+  let(:user) do
+   "#{require_env_value('SASL_USER')}%40#{require_env_value('SASL_HOST').upcase}"
+  end
+
+  let(:host) do
+    "#{require_env_value('SASL_HOST')}"
+  end
+
+  let(:kerberos_db) do
+    "#{require_env_value('KERBEROS_DB')}"
+  end
+
+  let(:auth_source) do
+    "#{require_env_value('SASL_DB')}"
+  end
+
+  let(:uri) do
+    uri = "mongodb://#{user}@#{host}/#{kerberos_db}?authMechanism=GSSAPI&authSource=#{auth_source}"
+  end
+
+  let(:client) do
+    Mongo::Client.new(uri, server_selection_timeout: 6.31)
+  end
+
+  let(:doc) do
+    client.database[:test].find.first
+  end
+
+  shared_examples_for 'correctly authenticates' do
+    it 'correctly authenticates' do
+      expect(doc['kerberos']).to eq(true)
+      expect(doc['authenticated']).to eq('yeah')
+    end
+  end
+
+  it_behaves_like 'correctly authenticates'
+
+  context 'when host is lowercased' do
+    let(:host) do
+      "#{require_env_value('SASL_HOST').downcase}"
+    end
+
+    it_behaves_like 'correctly authenticates'
+  end
+
+  context 'when host is uppercased' do
+    let(:host) do
+      "#{require_env_value('SASL_HOST').upcase}"
+    end
+
+    it_behaves_like 'correctly authenticates'
+  end
+
+  context 'when canonicalize_host_name is true' do
+    let(:host) do
+      "#{require_env_value('IP_ADDR')}"
+    end
+
+    let(:uri) do
+      uri = "mongodb://#{user}@#{host}/#{kerberos_db}?authMechanism=GSSAPI&authSource=#{auth_source}&authMechanismProperties=CANONICALIZE_HOST_NAME:true"
+    end
+
+    it 'correctly authenticates when using the IP' do
+      expect(doc['kerberos']).to eq(true)
+      expect(doc['authenticated']).to eq('yeah')
+    end
+  end
+end

data/spec/lite_spec_helper.rb

@@ -20,26 +20,25 @@ TRANSACTIONS_API_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/transactions_
 CHANGE_STREAMS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/change_streams/*.yml").sort
 CMAP_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/cmap/*.yml").sort
 AUTH_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/auth/*.yml").sort
-
-require 'mongo'
-require 'pp'
-
-autoload :Benchmark, 'benchmark'
+CLIENT_SIDE_ENCRYPTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/client_side_encryption/*.yml").sort
 
 unless ENV['CI']
+  # Load debuggers before loading the driver code, so that breakpoints
+  # can be placed in the driver code on file/class level.
   begin
     require 'byebug'
   rescue LoadError
-    # jruby - try pry
-    begin
-      require 'pry'
-    # jruby likes to raise random error classes, in this case
-    # NameError in addition to LoadError
-    rescue Exception
-    end
+    require 'ruby-debug'
   end
 end
 
+require 'mongo'
+require 'pp'
+
+autoload :Benchmark, 'benchmark'
+autoload :IceNine, 'ice_nine'
+autoload :Timecop, 'timecop'
+
 if BSON::Environment.jruby?
   require 'concurrent-ruby'
   PossiblyConcurrentArray = Concurrent::Array
@@ -56,31 +55,30 @@ unless SpecConfig.instance.client_debug?
 end
 Encoding.default_external = Encoding::UTF_8
 
-autoload :Timecop, 'timecop'
-
-require 'ice_nine'
 require 'support/matchers'
 require 'support/lite_constraints'
 require 'support/event_subscriber'
-require 'support/server_discovery_and_monitoring'
-require 'support/server_selection_rtt'
-require 'support/server_selection'
-require 'support/sdam_monitoring'
-require 'support/crud'
-require 'support/command_monitoring'
-require 'support/cmap'
-require 'runners/connection_string'
-require 'support/connection_string'
-require 'support/gridfs'
-require 'support/transactions'
-require 'support/change_streams'
 require 'support/common_shortcuts'
 require 'support/client_registry'
 require 'support/client_registry_macros'
+require 'support/crypt'
 require 'support/json_ext_formatter'
 require 'support/sdam_formatter_integration'
 require 'support/background_thread_registry'
-require 'support/auth'
+
+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'
 
 if SpecConfig.instance.mri?
   require 'timeout_interrupt'
@@ -122,7 +120,9 @@ RSpec.configure do |config|
 
   if SpecConfig.instance.ci?
     unless BSON::Environment.jruby?
-      Rfc::Rif.output_object_space_stats = true
+      if defined?(Rfc)
+        Rfc::Rif.output_object_space_stats = true
+      end
     end
   end
 
@@ -138,3 +138,8 @@ if SpecConfig.instance.active_support?
   require "active_support/time"
   require 'mongo/active_support'
 end
+
+if File.exist?('.env.private')
+  require 'dotenv'
+  Dotenv.load('.env.private')
+end