mongo 2.13.0.beta1 → 2.14.0

data/spec/integration/client_construction_spec.rb

@@ -10,6 +10,7 @@ describe 'Client construction' do
     ).merge(SpecConfig.instance.credentials_or_external_user(
       user: SpecConfig.instance.test_user.name,
       password: SpecConfig.instance.test_user.password,
+      auth_source: 'admin',
     ))
   end
 

data/spec/integration/client_side_encryption/auto_encryption_bulk_writes_spec.rb

@@ -113,7 +113,7 @@ describe 'Bulk writes with auto-encryption enabled' do
         it 'raises an exception' do
           expect do
             bulk_write.execute
-          end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+          end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
         end
       end
     end
@@ -162,15 +162,19 @@ describe 'Bulk writes with auto-encryption enabled' do
       context 'when one operation is larger than 16MiB' do
         let(:requests) do
           [
-            { update_one: { filter: { _id: 1 }, update: { ssn: 'a' * (Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE - 100) } } },
+            { update_one: { filter: { _id: 1 }, update: { ssn: 'a' * (Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE) } } },
             { update_one: { filter: { _id: 2 }, update: { ssn: 'a' * size_limit } } },
           ]
         end
 
+        before do
+          expect(requests.first.to_bson.length).to be > Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE
+        end
+
         it 'raises an exception' do
           expect do
             bulk_write.execute
-          end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+          end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
         end
       end
     end
@@ -255,7 +259,7 @@ describe 'Bulk writes with auto-encryption enabled' do
         it 'raises an exception' do
           expect do
             bulk_write.execute
-          end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+          end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
         end
       end
     end
@@ -346,7 +350,7 @@ describe 'Bulk writes with auto-encryption enabled' do
       it 'raises an exception' do
         expect do
           perform_bulk_write
-        end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+        end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
       end
     end
   end

data/spec/integration/connect_single_rs_name_spec.rb

@@ -18,7 +18,9 @@ describe 'Direct connection with RS name' do
     new_local_client(
       [SpecConfig.instance.addresses.first],
       SpecConfig.instance.test_options.merge(
-        replica_set: replica_set_name, connect: :direct))
+        replica_set: replica_set_name, connect: :direct,
+        server_selection_timeout: 3.32,
+      ))
   end
 
   context 'in replica set' do
@@ -31,7 +33,8 @@ describe 'Direct connection with RS name' do
 
       it 'creates a working client' do
         expect do
-          client.database.command(ismaster: 1)
+          res = client.database.command(ismaster: 1)
+          p res
         end.not_to raise_error
       end
     end

data/spec/integration/connection_pool_populator_spec.rb

@@ -4,7 +4,9 @@ describe 'Connection pool populator integration' do
   let(:options) { {} }
 
   let(:server_options) do
-    SpecConfig.instance.test_options.merge(options).merge(SpecConfig.instance.auth_options)
+    Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+      SpecConfig.instance.all_test_options,
+    )).update(options)
   end
 
   let(:address) do
@@ -269,7 +271,7 @@ describe 'Connection pool populator integration' do
   end
 
   describe 'when forking is enabled' do
-    only_mri
+    require_mri
 
     context 'when min size is provided' do
       min_server_version '2.8'

data/spec/integration/connection_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'runners/sdam_monitoring'
 
 describe 'Connections' do
   clean_slate
@@ -26,6 +25,9 @@ describe 'Connections' do
       # RSpec::Expectations::ExpectationNotMetError: expected Mongo::Error::SocketError, got #<NameError: undefined method `write' for class `Mongo::Socket'>
       fails_on_jruby
 
+      # 4.4 has two monitors and thus our socket mocks get hit twice
+      max_server_version '4.2'
+
       let(:exception) { Mongo::Error::SocketError }
 
       let(:error) do
@@ -44,7 +46,8 @@ describe 'Connections' do
       end
 
       context 'with sdam event subscription' do
-        let(:subscriber) { Mongo::SDAMMonitoring::TestSubscriber.new }
+
+        let(:subscriber) { EventSubscriber.new }
         let(:client) do
           ClientRegistry.instance.global_client('authorized').with(app_name: 'connection_integration').tap do |client|
             client.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
@@ -56,12 +59,12 @@ describe 'Connections' do
         end
 
         it 'publishes server description changed event' do
-          expect(subscriber.events).to be_empty
+          expect(subscriber.succeeded_events).to be_empty
 
           wait_for_all_servers(client.cluster)
 
           connection
-          subscriber.events.clear
+          subscriber.succeeded_events.clear
           error
 
           event = subscriber.first_event('server_description_changed_event')

data/spec/integration/crud_spec.rb

@@ -127,13 +127,13 @@ describe 'CRUD operations' do
   describe 'upsert' do
     context 'with default write concern' do
       it 'upserts' do
-        collection.count_documents({}).should == 0
+        collection.count_documents.should == 0
 
         res = collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
 
         res.documents.first['upserted'].length.should == 1
 
-        collection.count_documents({}).should == 1
+        collection.count_documents.should == 1
       end
     end
 
@@ -147,7 +147,7 @@ describe 'CRUD operations' do
       end
 
       it 'upserts' do
-        unack_collection.count_documents({}).should == 0
+        unack_collection.count_documents.should == 0
 
         res = unack_collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
 
@@ -155,7 +155,7 @@ describe 'CRUD operations' do
         # persisted (hopefully)
         sleep 0.25
 
-        unack_collection.count_documents({}).should == 1
+        unack_collection.count_documents.should == 1
       end
     end
   end

data/spec/integration/cursor_reaping_spec.rb

@@ -3,7 +3,17 @@ 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 +47,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 +113,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,6 +1,12 @@
 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
+  end
+
   let(:client) do
     authorized_client
   end

data/spec/integration/fork_reconnect_spec.rb

@@ -2,7 +2,7 @@ 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
@@ -139,5 +139,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/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

@@ -1,33 +1,14 @@
 require 'spec_helper'
 
-class TestHeartbeatSubscriber
-  def initialize
-    @started_events = []
-    @succeeded_events = []
-    @failed_events = []
-  end
-
-  attr_reader :started_events, :succeeded_events, :failed_events
-
-  def started(event)
-    @started_events << event
-  end
-
-  def succeeded(event)
-    @succeeded_events << event
-  end
-
-  def failed(event)
-    @failed_events << event
-  end
-end
-
 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) { TestHeartbeatSubscriber.new }
+  let(:subscriber) { EventSubscriber.new }
 
   before do
     Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)