mongo 2.15.0 → 2.18.1

data/spec/integration/sdam_error_handling_spec.rb

@@ -4,6 +4,8 @@
 require 'spec_helper'
 
 describe 'SDAM error handling' do
+  require_topology :single, :replica_set, :sharded
+
   clean_slate
 
   after do
@@ -14,9 +16,9 @@ describe 'SDAM error handling' do
 
   # These tests operate on specific servers, and don't work in a multi
   # shard cluster where multiple servers are equally eligible
-  require_no_multi_shard
+  require_no_multi_mongos
 
-  let(:diagnostic_subscriber) { VerboseEventSubscriber.new }
+  let(:diagnostic_subscriber) { Mrss::VerboseEventSubscriber.new }
 
   let(:client) do
     new_local_client(SpecConfig.instance.addresses,
@@ -288,7 +290,7 @@ describe 'SDAM error handling' do
   describe 'when there is an error on monitoring connection' do
     clean_slate_for_all
 
-    let(:subscriber) { EventSubscriber.new }
+    let(:subscriber) { Mrss::EventSubscriber.new }
 
     let(:set_subscribers) do
       client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, subscriber)

data/spec/integration/sdam_events_spec.rb

@@ -4,7 +4,7 @@
 require 'spec_helper'
 
 describe 'SDAM events' do
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   describe 'server closed event' do
     it 'is published when client is closed' do
@@ -50,13 +50,20 @@ describe 'SDAM events' do
     context 'pre-4.4 servers' do
       max_server_version '4.2'
 
+      let(:sdam_proc) do
+        Proc.new do |client|
+          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+        end
+      end
+
       let(:client) do
         new_local_client(SpecConfig.instance.addresses,
           # Heartbeat interval is bound by 500 ms
-          SpecConfig.instance.test_options.merge(heartbeat_frequency: 0.5),
-        ).tap do |client|
-          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
-        end
+          SpecConfig.instance.test_options.merge(
+            heartbeat_frequency: 0.5,
+            sdam_proc: sdam_proc
+          ),
+        )
       end
 
       it 'is published every heartbeat interval' do
@@ -78,13 +85,20 @@ describe 'SDAM events' do
     context '4.4+ servers' do
       min_server_fcv '4.4'
 
+      let(:sdam_proc) do
+        Proc.new do |client|
+          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+        end
+      end
+
       let(:client) do
         new_local_client(SpecConfig.instance.addresses,
           # Heartbeat interval is bound by 500 ms
-          SpecConfig.instance.test_options.merge(heartbeat_frequency: 0.5),
-        ).tap do |client|
-          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
-        end
+          SpecConfig.instance.test_options.merge(
+            heartbeat_frequency: 0.5,
+            sdam_proc: sdam_proc
+          ),
+        )
       end
 
       it 'is published up to twice every heartbeat interval' do
@@ -92,23 +106,25 @@ describe 'SDAM events' do
         sleep 3
         client.close
 
-        events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
+        started_events = subscriber.select_started_events(
+          Mongo::Monitoring::Event::ServerHeartbeatStarted
+        )
         # We could have up to 16 events and should have no fewer than 8 events.
         # Whenever an awaited hello succeeds while the regular monitor is
         # waiting, the regular monitor's next scan is pushed forward.
-        events.length.should >= 6
-        events.length.should <= 18
-        (started_awaited = events.select(&:awaited?)).should_not be_empty
-        (started_regular = events.reject(&:awaited?)).should_not be_empty
+        started_events.length.should >= 6
+        started_events.length.should <= 18
+        (started_awaited = started_events.select(&:awaited?)).should_not be_empty
+        (started_regular = started_events.reject(&:awaited?)).should_not be_empty
 
-        events = subscriber.select_completed_events(
+        completed_events = subscriber.select_completed_events(
           Mongo::Monitoring::Event::ServerHeartbeatSucceeded,
           Mongo::Monitoring::Event::ServerHeartbeatFailed,
         )
-        events.length.should >= 6
-        events.length.should <= 18
-        (succeeded_awaited = events.select(&:awaited?)).should_not be_empty
-        (succeeded_regular = events.reject(&:awaited?)).should_not be_empty
+        completed_events.length.should >= 6
+        completed_events.length.should <= 18
+        (succeeded_awaited = completed_events.select(&:awaited?)).should_not be_empty
+        (succeeded_regular = completed_events.reject(&:awaited?)).should_not be_empty
 
         # There may be in-flight hellos that don't complete, both
         # regular and awaited.
@@ -119,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/sdam_prose_spec.rb

@@ -11,7 +11,7 @@ describe 'SDAM prose tests' do
     min_server_fcv '4.4'
     require_topology :single
 
-    let(:subscriber) { EventSubscriber.new }
+    let(:subscriber) { Mrss::EventSubscriber.new }
 
     let(:client) do
       new_local_client(SpecConfig.instance.addresses,

data/spec/integration/server_monitor_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe 'Server::Monitor' do
+  require_topology :single, :replica_set, :sharded
 
   let(:client) do
     new_local_client([ClusterConfig.instance.primary_address_str],
@@ -15,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/server_selector_spec.rb

@@ -11,7 +11,7 @@ describe 'Server selector' do
   describe '#select_server' do
     # These tests operate on specific servers, and don't work in a multi
     # shard cluster where multiple servers are equally eligible
-    require_no_multi_shard
+    require_no_multi_mongos
 
     let(:result) { selector.select_server(cluster) }
 
@@ -52,6 +52,8 @@ describe 'Server selector' do
       end
 
       context 'there is no known primary' do
+        require_topology :single, :replica_set, :sharded
+
         before do
           primary_server = client.cluster.next_primary
           client.close
@@ -59,15 +61,30 @@ describe 'Server selector' do
           primary_server.unknown!
         end
 
-        it 'raises NoServerAvailable with a message explaining the situation' do
-          expect do
-            result
-          end.to raise_error(Mongo::Error::NoServerAvailable, /The cluster is disconnected \(client may have been closed\)/)
+        context 'non-lb' do
+          require_topology :single, :replica_set, :sharded
+
+          it 'raises NoServerAvailable with a message explaining the situation' do
+            expect do
+              result
+            end.to raise_error(Mongo::Error::NoServerAvailable, /The cluster is disconnected \(client may have been closed\)/)
+          end
+        end
+
+        context 'lb' do
+          require_topology :load_balanced
+
+          it 'returns the load balancer' do
+            expect(result).to be_a(Mongo::Server)
+            result.should be_load_balancer
+          end
         end
       end
     end
 
     context 'monitoring thread is dead' do
+      require_topology :single, :replica_set, :sharded
+
       before do
         client.cluster.servers.each do |server|
           server.monitor.instance_variable_get('@thread').kill

data/spec/integration/server_spec.rb

@@ -33,6 +33,8 @@ describe 'Server' do
       end
 
       context 'unknown server in disconnected cluster' do
+        require_topology :single, :replica_set, :sharded
+
         before do
           client.close
           server.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
@@ -144,7 +145,7 @@ describe 'SRV Monitoring' do
 
     context 'sharded cluster' do
       require_topology :sharded
-      require_multi_shard
+      require_multi_mongos
 
       it 'updates topology via SRV records' 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

@@ -32,7 +32,7 @@ describe 'Step down behavior' do
     end
   end
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:test_client) do
     authorized_client_without_any_retries.with(server_selection_timeout: 20).tap do |client|
@@ -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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Transaction pinning' do
+  let(:client) { authorized_client.with(max_pool_size: 4) }
+  let(:collection_name) { 'tx_pinning' }
+  let(:collection) { client[collection_name] }
+
+  before do
+    authorized_client[collection_name].insert_many([{test: 1}] * 200)
+  end
+
+  let(:server) { client.cluster.next_primary }
+
+  clean_slate
+
+  context 'non-lb' do
+    require_topology :sharded
+    min_server_fcv '4.2'
+
+    # Start several transactions, then complete each of them.
+    # Force each transaction to be on its own connection.
+
+    before do
+      4.times do |i|
+        # Collections cannot be created inside transactions.
+        client["tx_pin_t#{i}"].drop
+        client["tx_pin_t#{i}"].create
+      end
+    end
+
+    it 'works' do
+      sessions = []
+      connections = []
+
+      4.times do |i|
+        session = client.start_session
+        session.start_transaction
+        client["tx_pin_t#{i}"].insert_one({test: 1}, session: session)
+        session.pinned_server.should be_a(Mongo::Server)
+        sessions << session
+        connections << server.pool.check_out
+      end
+
+      server.pool.size.should == 4
+
+      connections.each do |c|
+        server.pool.check_in(c)
+      end
+
+      sessions.each_with_index do |session, i|
+        client["tx_pin_t#{i}"].insert_one({test: 2}, session: session)
+        session.commit_transaction
+      end
+    end
+  end
+
+  context 'lb' do
+    require_topology :load_balanced
+    min_server_fcv '4.2'
+
+    # In load-balanced topology, we cannot create new connections to a
+    # particular service.
+
+    context 'when no connection is available' do
+
+      before do
+        client["tx_pin"].drop
+        client["tx_pin"].create
+      end
+
+      it 'raises ConnectionCheckOutTimeout' do
+        session = client.start_session
+        session.start_transaction
+        client["tx_pin"].insert_one({test: 1}, session: session)
+        session.pinned_server.should be nil
+        session.pinned_connection_global_id.should_not be nil
+
+        server.pool.size.should == 1
+        server.pool.clear
+        server.pool.size.should == 0
+
+        lambda do
+          client["tx_pin"].insert_one({test: 2}, session: session)
+        end.should raise_error(Mongo::Error::ConnectionCheckOutTimeout)
+      end
+    end
+
+    context 'when connection is available' do
+
+      it 'uses the available connection' do
+        sessions = []
+        connections = []
+
+        4.times do |i|
+          session = client.start_session
+          session.start_transaction
+          client["tx_pin_t#{i}"].insert_one({test: 1}, session: session)
+          session.pinned_server.should be nil
+          session.pinned_connection_global_id.should_not be nil
+          sessions << session
+          connections << server.pool.check_out
+        end
+
+        server.pool.size.should == 4
+
+        connections.each do |c|
+          server.pool.check_in(c)
+        end
+
+        sessions.each_with_index do |session, i|
+          client["tx_pin_t#{i}"].insert_one({test: 2}, session: session)
+          session.commit_transaction
+        end
+      end
+    end
+  end
+end