mongo 2.17.2 → 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 }
@@ -693,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
@@ -721,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
@@ -1072,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
@@ -1086,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/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

data/spec/integration/snapshot_query_examples_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Snapshot Query Examples' do
+  require_topology :replica_set, :sharded
+  require_no_auth
+  require_no_tls
+
+  min_server_fcv '5.0'
+
+  let(:uri_string) do
+    "mongodb://#{SpecConfig.instance.addresses.join(',')}/?w=majority"
+  end
+
+  context "Snapshot Query Example 1" do
+    before do
+      client = authorized_client.use('pets')
+      client['cats'].delete_many
+      client['dogs'].delete_many
+
+      client['cats'].insert_one(
+        name: "Whiskers",
+        color: "white",
+        age: 10,
+        adoptable: true
+      )
+
+      client['dogs'].insert_one(
+        name: "Pebbles",
+        color: "Brown",
+        age: 10,
+        adoptable: true
+      )
+      if ClusterConfig.instance.topology == :sharded
+        run_mongos_distincts "pets", "cats"
+      else
+        wait_for_snapshot(db: 'pets', collection: 'cats')
+        wait_for_snapshot(db: 'pets', collection: 'dogs')
+      end
+    end
+
+    it "returns a snapshot of the data" do
+
+      adoptable_pets_count = 0
+
+      # Start Snapshot Query Example 1
+
+      client = Mongo::Client.new(uri_string, database: "pets")
+
+      client.start_session(snapshot: true) do |session|
+        adoptable_pets_count = client['cats'].aggregate([
+          { "$match": { "adoptable": true } },
+          { "$count": "adoptable_cats_count" }
+        ], session: session).first["adoptable_cats_count"]
+
+        adoptable_pets_count += client['dogs'].aggregate([
+          { "$match": { "adoptable": true } },
+          { "$count": "adoptable_dogs_count" }
+        ], session: session).first["adoptable_dogs_count"]
+
+        puts adoptable_pets_count
+      end
+
+      # End Snapshot Query Example 1
+
+      expect(adoptable_pets_count).to eq 2
+      client.close
+    end
+  end
+
+  context "Snapshot Query Example 2" do
+    before do
+      client = authorized_client.use('retail')
+      client['sales'].delete_many
+
+      client['sales'].insert_one(
+        shoeType: "boot",
+        price: 30,
+        saleDate: Time.now
+      )
+
+      if ClusterConfig.instance.topology == :sharded
+        run_mongos_distincts "retail", "sales"
+      else
+        wait_for_snapshot(db: 'retail', collection: 'sales')
+      end
+    end
+
+    it "returns a snapshot of the data" do
+
+      total = 0
+
+      # Start Snapshot Query Example 2
+
+      client = Mongo::Client.new(uri_string, database: "retail")
+
+      client.start_session(snapshot: true) do |session|
+        total = client['sales'].aggregate([
+          {
+             "$match": {
+                "$expr": {
+                   "$gt": [
+                      "$saleDate",
+                      {
+                         "$dateSubtract": {
+                            startDate: "$$NOW",
+                            unit: "day",
+                            amount: 1
+                         }
+                      }
+                   ]
+                 }
+              }
+          },
+          { "$count": "total_daily_sales" }
+        ], session: session).first["total_daily_sales"]
+      end
+
+      # End Snapshot Query Example 2
+
+      expect(total).to eq 1
+      client.close
+    end
+  end
+end

data/spec/integration/srv_monitoring_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 
 describe 'SRV Monitoring' do
   clean_slate_for_all
+  require_external_connectivity
 
   context 'with SRV lookups mocked at Resolver' do
     let(:srv_result) do
@@ -402,5 +403,42 @@ describe 'SRV Monitoring' do
         end
       end
     end
+
+    context 'when the client mocks the srvServiceName' do
+
+      let(:uri) do
+        "mongodb+srv://test-fake.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true&srvServiceName=customname"
+      end
+
+      it 'finds the records using the custom service name' do
+
+        rules = [
+          ['_customname._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27998, 'localhost.test.build.10gen.cc'],
+            [0, 0, 27999, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          15.times do
+            address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+            if address_strs == %w(
+                localhost.test.build.10gen.cc:27998
+                localhost.test.build.10gen.cc:27999
+              )
+            then
+              break
+            end
+            sleep 1
+          end
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27998
+            localhost.test.build.10gen.cc:27999
+          ))
+        end
+      end
+    end
   end
 end

data/spec/integration/srv_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 
 describe 'SRV lookup' do
   context 'end to end' do
+    require_external_connectivity
 
     # JRuby apparently does not implement non-blocking UDP I/O which is used
     # by RubyDNS:

data/spec/integration/step_down_spec.rb

@@ -134,10 +134,14 @@ describe 'Step down behavior' do
     end
 
     let(:fail_point) do
-      { configureFailPoint: 'failCommand', data: {
-        # There is currently no way to turn write retries on not master
-        # errors off - therefore set the number of fails to 2
-        failCommands: ['insert'], errorCode: fail_point_code, }, mode: {times: 2} }
+      {
+        configureFailPoint: 'failCommand',
+        data: {
+          failCommands: ['insert'],
+          errorCode: fail_point_code,
+        },
+        mode: { times: 1 }
+      }
     end
 
     before do
@@ -165,6 +169,10 @@ describe 'Step down behavior' do
         end.to raise_error(Mongo::Error::OperationFailure, /10107/)
 
         expect(subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(0)
+
+        expect do
+          collection.insert_one(test: 1)
+        end.to_not raise_error
       end
     end
 
@@ -184,6 +192,10 @@ describe 'Step down behavior' do
         end.to raise_error(Mongo::Error::OperationFailure, /10107/)
 
         expect(subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
+
+        expect do
+          collection.insert_one(test: 1)
+        end.to_not raise_error
       end
     end
 
@@ -201,6 +213,10 @@ describe 'Step down behavior' do
         end.to raise_error(Mongo::Error::OperationFailure, /11600/)
 
         expect(subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
+
+        expect do
+          collection.insert_one(test: 1)
+        end.to_not raise_error
       end
     end
   end

data/spec/integration/transaction_pinning_spec.rb

@@ -76,7 +76,7 @@ describe 'Transaction pinning' do
         session.start_transaction
         client["tx_pin"].insert_one({test: 1}, session: session)
         session.pinned_server.should be nil
-        session.pinned_service_id.should_not be nil
+        session.pinned_connection_global_id.should_not be nil
 
         server.pool.size.should == 1
         server.pool.clear
@@ -99,7 +99,7 @@ describe 'Transaction pinning' do
           session.start_transaction
           client["tx_pin_t#{i}"].insert_one({test: 1}, session: session)
           session.pinned_server.should be nil
-          session.pinned_service_id.should_not be nil
+          session.pinned_connection_global_id.should_not be nil
           sessions << session
           connections << server.pool.check_out
         end