mongo 2.17.4 → 2.18.0.beta1

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
 
   shared_examples 'verifies' do
     context 'mri' 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/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,44 +135,4 @@ 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

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

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

data/spec/integration/versioned_api_examples_spec.rb

@@ -9,9 +9,10 @@ describe 'Versioned API examples' do
   # the tests to simple configurations
   require_no_auth
   require_no_tls
+  min_server_version("5.0")
 
   let(:uri_string) do
-    "mongodb://#{SpecConfig.instance.addresses.join(',')}"
+    "mongodb://#{SpecConfig.instance.addresses.join(',')}/versioned-api-examples"
   end
 
   it 'Versioned API example 1' do
@@ -67,48 +68,53 @@ describe 'Versioned API examples' do
     client.close
   end
 
-  it "Versioned API Strict Migration Example" do
-    client = Mongo::Client.new(uri_string, server_api: {version: "1", strict: true})
-    client[:sales].drop
+  # See also RUBY-2922 for count in versioned api v1.
+  context 'servers that exclude count from versioned api' do
+    max_server_version '5.0.8'
 
-    # Start Versioned API Example 5
+    it "Versioned API Strict Migration Example" do
+      client = Mongo::Client.new(uri_string, server_api: {version: "1", strict: true})
+      client[:sales].drop
 
-    client[:sales].insert_many([
-      { _id: 1, item: "abc", price: 10, quantity: 2,  date: DateTime.parse("2021-01-01T08:00:00Z") },
-      { _id: 2, item: "jkl", price: 20, quantity: 1,  date: DateTime.parse("2021-02-03T09:00:00Z") },
-      { _id: 3, item: "xyz", price: 5,  quantity: 5,  date: DateTime.parse("2021-02-03T09:05:00Z") },
-      { _id: 4, item: "abc", price: 10, quantity: 10, date: DateTime.parse("2021-02-15T08:00:00Z") },
-      { _id: 5, item: "xyz", price: 5,  quantity: 10, date: DateTime.parse("2021-02-15T09:05:00Z") },
-      { _id: 6, item: "xyz", price: 5,  quantity: 5,  date: DateTime.parse("2021-02-15T12:05:10Z") },
-      { _id: 7, item: "xyz", price: 5,  quantity: 10, date: DateTime.parse("2021-02-15T14:12:12Z") },
-      { _id: 8, item: "abc", price: 10, quantity: 5,  date: DateTime.parse("2021-03-16T20:20:13Z") }
-    ])
+      # Start Versioned API Example 5
 
-    # End Versioned API Example 5
+      client[:sales].insert_many([
+        { _id: 1, item: "abc", price: 10, quantity: 2,  date: DateTime.parse("2021-01-01T08:00:00Z") },
+        { _id: 2, item: "jkl", price: 20, quantity: 1,  date: DateTime.parse("2021-02-03T09:00:00Z") },
+        { _id: 3, item: "xyz", price: 5,  quantity: 5,  date: DateTime.parse("2021-02-03T09:05:00Z") },
+        { _id: 4, item: "abc", price: 10, quantity: 10, date: DateTime.parse("2021-02-15T08:00:00Z") },
+        { _id: 5, item: "xyz", price: 5,  quantity: 10, date: DateTime.parse("2021-02-15T09:05:00Z") },
+        { _id: 6, item: "xyz", price: 5,  quantity: 5,  date: DateTime.parse("2021-02-15T12:05:10Z") },
+        { _id: 7, item: "xyz", price: 5,  quantity: 10, date: DateTime.parse("2021-02-15T14:12:12Z") },
+        { _id: 8, item: "abc", price: 10, quantity: 5,  date: DateTime.parse("2021-03-16T20:20:13Z") }
+      ])
 
-    expect do
-      client.database.command(count: :sales)
-    end.to raise_error(Mongo::Error::OperationFailure)
+      # End Versioned API Example 5
 
-    # Start Versioned API Example 6
+      expect do
+        client.database.command(count: :sales)
+      end.to raise_error(Mongo::Error::OperationFailure)
 
-    # Mongo::Error::OperationFailure:
-    #   [323:APIStrictError]: Provided apiStrict:true, but the command count is not in API Version 1. Information on supported commands and migrations in API Version 1 can be found at https://dochub.mongodb.org/core/manual-versioned-api
+      # Start Versioned API Example 6
 
-    # End Versioned API Example 6
+      # Mongo::Error::OperationFailure:
+      #   [323:APIStrictError]: Provided apiStrict:true, but the command count is not in API Version 1. Information on supported commands and migrations in API Version 1 can be found at https://dochub.mongodb.org/core/manual-versioned-api
 
-    # Start Versioned API Example 7
+      # End Versioned API Example 6
 
-    client[:sales].count_documents
+      # Start Versioned API Example 7
 
-    # End Versioned API Example 7
+      client[:sales].count_documents
 
-    # Start Versioned API Example 8
+      # End Versioned API Example 7
 
-    # 8
+      # Start Versioned API Example 8
 
-    # End Versioned API Example 8
-    # Do not leak clients.
-    client.close
+      # 8
+
+      # End Versioned API Example 8
+      # Do not leak clients.
+      client.close
+    end
   end
 end