mongo 2.17.1 → 2.18.1

data/spec/integration/client_side_encryption/unique_index_on_key_alt_names_prose_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe "Decryption events" do
+  require_enterprise
+  min_server_fcv "4.2"
+  require_libmongocrypt
+  include_context "define shared FLE helpers"
+
+  let(:client) do
+    ClientRegistry.instance.new_local_client(
+      SpecConfig.instance.addresses,
+      SpecConfig.instance.test_options.merge(
+        database: SpecConfig.instance.test_db,
+      )
+    )
+  end
+
+  let(:client_encryption) do
+    Mongo::ClientEncryption.new(
+      client,
+      key_vault_namespace: "#{key_vault_db}.#{key_vault_coll}",
+      kms_providers: local_kms_providers
+    )
+  end
+
+  let(:existing_key_alt_name) do
+    'def'
+  end
+
+  let(:existing_key_id) do
+    client_encryption.create_data_key('local', key_alt_names: [existing_key_alt_name])
+  end
+
+  before(:each) do
+    client.use(key_vault_db)[key_vault_coll].drop
+    client.use(key_vault_db).command({
+      createIndexes: key_vault_coll,
+      indexes: [
+        {
+          name: "keyAltNames_1",
+          key: { "keyAltNames": 1 },
+          unique: true,
+          partialFilterExpression: { keyAltNames: { "$exists" => true } },
+        },
+      ],
+      writeConcern: { w: "majority" },
+    })
+    # Force key creation
+    existing_key_id
+  end
+
+  it 'tests create_data_key' do
+    expect do
+      client_encryption.create_data_key('local', key_alt_names: ['abc'])
+    end.not_to raise_error
+
+    expect do
+      client_encryption.create_data_key('local', key_alt_names: [existing_key_alt_name])
+    end.to raise_error(Mongo::Error::OperationFailure, /E11000/) # duplicate key error
+  end
+
+  it 'tests add_key_alt_name' do
+    key_id = client_encryption.create_data_key('local')
+    expect do
+      client_encryption.add_key_alt_name(key_id, 'abc')
+    end.not_to raise_error
+
+    expect do
+      key_document = client_encryption.add_key_alt_name(key_id, 'abc')
+      expect(key_document['keyAltNames']).to include('abc')
+    end.not_to raise_error
+
+    expect do
+      client_encryption.add_key_alt_name(key_id, existing_key_alt_name)
+    end.to raise_error(Mongo::Error::OperationFailure, /E11000/) # duplicate key error
+
+    expect do
+      key_document = client_encryption.add_key_alt_name(existing_key_id, existing_key_alt_name)
+      expect(key_document['keyAltNames']).to include(existing_key_alt_name)
+    end.not_to raise_error
+  end
+end

data/spec/integration/client_side_encryption/views_spec.rb

@@ -24,7 +24,7 @@ describe 'Client-Side Encryption' do
         SpecConfig.instance.test_options.merge(
           auto_encryption_options: {
             kms_providers: local_kms_providers,
-            key_vault_namespace: 'admin.datakeys',
+            key_vault_namespace: 'keyvault.datakeys',
             # Spawn mongocryptd on non-default port for sharded cluster tests
             extra_options: extra_options,
           },

data/spec/integration/client_update_spec.rb

@@ -15,8 +15,8 @@ describe Mongo::Client do
     include_context 'with local kms_providers'
 
     before do
-      authorized_client.use(:admin)[:datakeys].drop
-      authorized_client.use(:admin)[:datakeys].insert_one(data_key)
+      authorized_client.use(:keyvault)[:datakeys].drop
+      authorized_client.use(:keyvault)[:datakeys].insert_one(data_key)
       authorized_client.use(:auto_encryption)[:users].drop
       authorized_client.use(:auto_encryption)[:users,
         {

data/spec/integration/crud_spec.rb

@@ -240,6 +240,18 @@ describe 'CRUD operations' do
   end
 
   describe 'insert' do
+    context 'user documents' do
+      let(:doc) do
+        IceNine.deep_freeze(test: 42)
+      end
+
+      it 'does not mutate user documents' do
+        lambda do
+          collection.insert_one(doc)
+        end.should_not raise_error
+      end
+    end
+
     context 'inserting a BSON::Int64' do
       before do
         collection.insert_one(int64: BSON::Int64.new(42))

data/spec/integration/cursor_pinning_spec.rb

@@ -87,7 +87,7 @@ describe 'Cursor pinning' do
 
         enums = []
         connections = []
-        service_ids = []
+        connection_ids = []
 
         4.times do
           view = collection.find({}, batch_size: 1)
@@ -96,11 +96,11 @@ describe 'Cursor pinning' do
           enum.next
 
           enums << enum
-          service_ids << view.cursor.initial_result.connection_description.service_id
+          connection_ids << view.cursor.initial_result.connection_global_id
           connections << server.pool.check_out
         end
 
-        service_ids.uniq.length.should be > 1
+        connection_ids.uniq.length.should be > 1
 
         server.pool.size.should == 4
 

data/spec/integration/fork_reconnect_spec.rb

@@ -151,32 +151,37 @@ describe 'fork reconnect' do
     #   * 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
+        session = client.get_session.materialize_if_needed
         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_session = client.get_session.materialize_if_needed
             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)
+        session = client.get_session.materialize_if_needed
+        session_id = session.session_id
+        expect(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.
+      #   * 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
+        session = client.get_session.materialize_if_needed
         parent_lsid = session.session_id
 
         if pid = fork
@@ -186,14 +191,16 @@ describe 'fork reconnect' do
           Utils.wrap_forked_child do
             client.reconnect
             session.end_session
-            child_session = client.get_session
+            child_session = client.get_session.materialize_if_needed
+
             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)
+        session_id = client.get_session.materialize_if_needed.session_id
+        expect(session_id).to eq(parent_lsid)
       end
     end
   end

data/spec/integration/grid_fs_bucket_spec.rb

@@ -26,8 +26,8 @@ describe 'GridFS bucket integration' do
           actual = stream.read
         end
 
-        actual.encoding.name.should == 'ASCII-8BIT'
-        actual.should == data.dup.force_encoding('binary')
+        actual.encoding.should == Encoding::BINARY
+        actual.should == data.b
       end
     end
 
@@ -41,7 +41,7 @@ describe 'GridFS bucket integration' do
 
     context 'in UTF-8 encoding' do
       let(:data_to_write) do
-        data.encoding.name.should == 'UTF-8'
+        data.encoding.should == Encoding::UTF_8
         data.freeze
       end
 

data/spec/integration/ocsp_verifier_spec.rb

@@ -7,6 +7,7 @@ require 'webrick'
 describe Mongo::Socket::OcspVerifier do
   require_ocsp_verifier
   with_openssl_debug
+  retry_test sleep: 5
 
   shared_examples 'verifies' do
     context 'mri' do
@@ -334,6 +335,8 @@ describe Mongo::Socket::OcspVerifier do
     # have a path in the OCSP URI (which the test also asserts).
     # Note that these certificates expire in 3 months and need to be replaced
     # with a more permanent solution.
+    # Use the spec/support/certificates/retrieve-atlas-cert script to retrieve
+    # current certificates from Atlas.
     let(:cert_path) { File.join(File.dirname(__FILE__), '../support/certificates/atlas-ocsp.crt') }
     let(:ca_cert_path) { File.join(File.dirname(__FILE__), '../support/certificates/atlas-ocsp-ca.crt') }
     let(:cert_store) do

data/spec/integration/query_cache_spec.rb

@@ -21,11 +21,11 @@ describe 'QueryCache' do
     # these tests.
     #
     # Other session leaks will be detected and addressed as part of RUBY-2391.
-    SessionRegistry.instance.clear_registry
+    Mrss::SessionRegistry.instance.clear_registry
   end
 
   after do
-    SessionRegistry.instance.verify_sessions_ended!
+    Mrss::SessionRegistry.instance.verify_sessions_ended!
   end
 
   let(:subscriber) { Mrss::EventSubscriber.new }
@@ -345,18 +345,69 @@ describe 'QueryCache' do
 
         it 'uses the cache' do
           results_limit_5 = authorized_collection.find.limit(5).to_a
+          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
           results_limit_3 = authorized_collection.find.limit(3).to_a
+          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
           results_no_limit = authorized_collection.find.to_a
+          results_limit_0 = authorized_collection.find.limit(0).to_a
+
+
+          expect(results_limit_5.length).to eq(5)
+          expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+          expect(results_limit_negative_5.length).to eq(5)
+          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+          expect(results_limit_3.length).to eq(3)
+          expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+          expect(results_limit_negative_3.length).to eq(3)
+          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+          expect(results_no_limit.length).to eq(10)
+          expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+          expect(results_limit_0.length).to eq(10)
+          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+          expect(events.length).to eq(1)
+        end
+      end
+
+      context 'when the first query has a 0 limit' do
+        before do
+          authorized_collection.find.limit(0).to_a
+        end
+
+        it 'uses the cache' do
+          results_limit_5 = authorized_collection.find.limit(5).to_a
+          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
+          results_limit_3 = authorized_collection.find.limit(3).to_a
+          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
+          results_no_limit = authorized_collection.find.to_a
+          results_limit_0 = authorized_collection.find.limit(0).to_a
 
           expect(results_limit_5.length).to eq(5)
           expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
 
+          expect(results_limit_negative_5.length).to eq(5)
+          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+
           expect(results_limit_3.length).to eq(3)
           expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
 
+          expect(results_limit_negative_3.length).to eq(3)
+          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+
           expect(results_no_limit.length).to eq(10)
           expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
 
+
+          expect(results_limit_0.length).to eq(10)
+          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
           expect(events.length).to eq(1)
         end
       end
@@ -391,6 +442,21 @@ describe 'QueryCache' do
           end
         end
 
+        context 'and two queries are performed with a larger negative limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(-3).to_a
+            results2 = authorized_collection.find.limit(-3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
         context 'and the second query has a smaller limit' do
           let(:results) { authorized_collection.find.limit(1).to_a }
 
@@ -401,6 +467,99 @@ describe 'QueryCache' do
           end
         end
 
+        context 'and the second query has a smaller negative limit' do
+          let(:results) { authorized_collection.find.limit(-1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
+        context 'and the second query has no limit' do
+          it 'queries again' do
+            expect(authorized_collection.find.to_a.count).to eq(10)
+            expect(events.length).to eq(2)
+          end
+        end
+      end
+
+      context 'when the first query has a negative limit' do
+        before do
+          authorized_collection.find.limit(-2).to_a
+        end
+
+        context 'and the second query has a larger limit' do
+          let(:results) { authorized_collection.find.limit(3).to_a }
+
+          it 'queries again' do
+            expect(results.length).to eq(3)
+            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and the second query has a larger negative limit' do
+          let(:results) { authorized_collection.find.limit(-3).to_a }
+
+          it 'queries again' do
+            expect(results.length).to eq(3)
+            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and two queries are performed with a larger limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(3).to_a
+            results2 = authorized_collection.find.limit(3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and two queries are performed with a larger negative limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(-3).to_a
+            results2 = authorized_collection.find.limit(-3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and the second query has a smaller limit' do
+          let(:results) { authorized_collection.find.limit(1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
+        context 'and the second query has a smaller negative limit' do
+          let(:results) { authorized_collection.find.limit(-1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
         context 'and the second query has no limit' do
           it 'queries again' do
             expect(authorized_collection.find.to_a.count).to eq(10)
@@ -534,7 +693,7 @@ describe 'QueryCache' do
     end
 
     [:find_one_and_delete, :find_one_and_replace, :find_one_and_update,
-      :update_one, :replace_one].each do |method|
+      :replace_one].each do |method|
       context "when updating with #{method}" do
         context 'when updating and querying from same collection' do
           before do
@@ -562,28 +721,30 @@ describe 'QueryCache' do
       end
     end
 
-    context 'when updating with #update_many' do
-      context 'when updating and querying from same collection' do
-        before do
-          authorized_collection.find.to_a
-          authorized_collection.update_many({ field: 'value' }, { "$inc" => { :field =>  1 } })
-        end
+    [:update_one, :update_many].each do |method|
+      context "when updating with ##{method}" do
+        context 'when updating and querying from same collection' do
+          before do
+            authorized_collection.find.to_a
+            authorized_collection.send(method, { field: 'value' }, { "$inc" => { :field =>  1 } })
+          end
 
-        it 'queries again' do
-          authorized_collection.find.to_a
-          expect(events.length).to eq(2)
+          it 'queries again' do
+            authorized_collection.find.to_a
+            expect(events.length).to eq(2)
+          end
         end
-      end
 
-      context 'when updating and querying from different collections' do
-        before do
-          authorized_collection.find.to_a
-          authorized_client['different_collection'].update_many({ field: 'value' }, { "$inc" => { :field =>  1 } })
-        end
+        context 'when updating and querying from different collections' do
+          before do
+            authorized_collection.find.to_a
+            authorized_client['different_collection'].send(method, { field: 'value' }, { "$inc" => { :field =>  1 } })
+          end
 
-        it 'uses the cached query' do
-          authorized_collection.find.to_a
-          expect(events.length).to eq(1)
+          it 'uses the cached query' do
+            authorized_collection.find.to_a
+            expect(events.length).to eq(1)
+          end
         end
       end
     end
@@ -913,7 +1074,7 @@ describe 'QueryCache' do
     end
 
     [:find_one_and_delete, :find_one_and_replace, :find_one_and_update,
-      :update_one, :replace_one].each do |method|
+      :replace_one].each do |method|
       context "when #{method} is performed on another collection" do
         before do
           aggregation.to_a
@@ -927,15 +1088,17 @@ describe 'QueryCache' do
       end
     end
 
-    context 'when update_many is performed on another collection' do
-      before do
-        aggregation.to_a
-        authorized_client['different_collection'].update_many({ field: 'value' }, { "$inc" => { :field =>  1 } })
-        aggregation.to_a
-      end
+    [:update_one, :update_many].each do |method|
+      context 'when update_many is performed on another collection' do
+        before do
+          aggregation.to_a
+          authorized_client['different_collection'].send(method, { field: 'value' }, { "$inc" => { :field =>  1 } })
+          aggregation.to_a
+        end
 
-      it 'queries again' do
-        expect(events.length).to eq(2)
+        it 'queries again' do
+          expect(events.length).to eq(2)
+        end
       end
     end
 

data/spec/integration/reconnect_spec.rb

@@ -73,6 +73,7 @@ describe 'Client after reconnect' do
   end
 
   context 'SRV monitor thread' do
+    require_external_connectivity
 
     let(:uri) do
       "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}"
@@ -140,6 +141,7 @@ describe 'Client after reconnect' do
     end
 
     context 'in unknown topology' do
+      require_external_connectivity
 
       # JRuby apparently does not implement non-blocking UDP I/O which is used
       # by RubyDNS:

data/spec/integration/retryable_writes/retryable_writes_36_and_older_spec.rb

@@ -731,7 +731,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:operation) do
-      collection.bulk_write([{ update_many: { filter: { a: 0 }, update: { a: 1 } } }])
+      collection.bulk_write([{ update_many: { filter: { a: 0 }, update: { "$set" => { a: 1 } } } }])
     end
 
     let(:expectation) do

data/spec/integration/sdam_events_spec.rb

@@ -135,4 +135,44 @@ describe 'SDAM events' do
       end
     end
   end
+
+  describe 'server description changed' do
+    require_topology :single
+
+    let(:sdam_proc) do
+      Proc.new do |client|
+        client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, subscriber)
+      end
+    end
+
+    let(:client) do
+      new_local_client(SpecConfig.instance.addresses,
+        # Heartbeat interval is bound by 500 ms
+        SpecConfig.instance.test_options.merge(client_options).merge(
+          heartbeat_frequency: 0.5,
+          sdam_proc: sdam_proc,
+        ),
+      )
+    end
+
+    let(:client_options) do
+      {}
+    end
+
+    it 'is not published when there are no changes in server state' do
+      client
+      sleep 6
+      client.close
+
+      events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerDescriptionChanged)
+
+      # In 6 seconds we should have about 10 or 12 heartbeats.
+      # We expect 1 or 2 description changes:
+      # The first one from unknown to known,
+      # The second one because server changes the fields it returns based on
+      # driver server check payload (e.g. ismaster/isWritablePrimary).
+      events.length.should >= 1
+      events.length.should <= 2
+    end
+  end
 end

data/spec/integration/server_monitor_spec.rb

@@ -16,7 +16,8 @@ describe 'Server::Monitor' do
     {heartbeat_frequency: 1}
   end
 
-  it 'refreshes server descriptions in background', retry: 3 do
+  retry_test
+  it 'refreshes server descriptions in background' do
     server = client.cluster.next_primary
 
     expect(server.description).not_to be_unknown

data/spec/integration/size_limit_spec.rb

@@ -4,6 +4,9 @@
 require 'spec_helper'
 
 describe 'BSON & command size limits' do
+  # https://jira.mongodb.org/browse/RUBY-3016
+  retry_test
+
   let(:max_document_size) { 16*1024*1024 }
 
   before do
@@ -75,7 +78,7 @@ describe 'BSON & command size limits' do
   end
 
   it 'fails on the driver when an update larger than 16MiB is performed' do
-    document = { key: 'a' * (max_document_size - 14) }
+    document = { "$set" => { key: 'a' * (max_document_size - 25) } }
     expect(document.to_bson.length).to eq(max_document_size+1)
 
     lambda do