mongo 2.11.4 → 2.18.1

data/spec/integration/srv_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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:
+    # NotImplementedError: recvmsg_nonblock is not implemented
+    fails_on_jruby
+
+    before(:all) do
+      require 'support/dns'
+    end
+
+    let(:uri) do
+      "mongodb+srv://test-fake.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true"
+    end
+
+    let(:client) do
+      new_local_client(uri,
+        SpecConfig.instance.ssl_options.merge(
+          server_selection_timeout: 3.16,
+          timeout: 4.11,
+          connect_timeout: 4.12,
+          resolv_options: {
+            nameserver: 'localhost',
+            nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],
+          },
+        ),
+      )
+    end
+
+    context 'DNS resolver not responding' do
+      it 'fails to create client' do
+        lambda do
+          client
+        end.should raise_error(Mongo::Error::NoSRVRecords, /The DNS query returned no SRV records for 'test-fake.test.build.10gen.cc'/)
+      end
+
+      it 'times out in connect_timeout' do
+        start_time = Time.now
+
+        lambda do
+          client
+        end.should raise_error(Mongo::Error::NoSRVRecords)
+
+        elapsed_time = Time.now - start_time
+        elapsed_time.should > 4
+        # The number of queries performed depends on local DNS search suffixes,
+        # therefore we cannot reliably assert how long it would take for this
+        # resolution to time out.
+        #elapsed_time.should < 8
+      end
+    end
+  end
+end

data/spec/integration/ssl_uri_options_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'SSL connections with URI options' do
@@ -20,6 +23,6 @@ describe 'SSL connections with URI options' do
 
   it 'successfully connects and runs an operation' do
     client = new_local_client(uri)
-    expect { client[:foo].count_documents({}) }.not_to raise_error
+    expect { client[:foo].count_documents }.not_to raise_error
   end
-end
+end

data/spec/integration/step_down_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Step down behavior' do
@@ -29,11 +32,11 @@ describe 'Step down behavior' do
     end
   end
 
-  let(:event_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|
-      client.subscribe(Mongo::Monitoring::CONNECTION_POOL, event_subscriber)
+      client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
     end
   end
 
@@ -48,8 +51,8 @@ describe 'Step down behavior' do
 
     let(:subscribed_client) do
       test_client.tap do |client|
-        client.subscribe(Mongo::Monitoring::COMMAND, EventSubscriber)
-        client.subscribe(Mongo::Monitoring::CONNECTION_POOL, EventSubscriber)
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
       end
     end
 
@@ -65,13 +68,13 @@ describe 'Step down behavior' do
     it 'continues through step down' do
 
       subscribed_client.cluster.next_primary.pool.clear
-      event_subscriber.clear_events!
+      subscriber.clear_events!
 
       # get the first item
       item = enum.next
       expect(item['test']).to eq(1)
 
-      connection_created_events = EventSubscriber.published_events.select do |event|
+      connection_created_events = subscriber.published_events.select do |event|
         event.is_a?(Mongo::Monitoring::Event::Cmap::ConnectionCreated)
       end
       expect(connection_created_events).not_to be_empty
@@ -79,7 +82,7 @@ describe 'Step down behavior' do
       current_primary = subscribed_client.cluster.next_primary
       ClusterTools.instance.change_primary
 
-      EventSubscriber.clear_events!
+      subscriber.clear_events!
 
       # exhaust the batch
       9.times do
@@ -90,14 +93,14 @@ describe 'Step down behavior' do
       item = enum.next
       expect(item['test']).to eq(1)
 
-      get_more_events = EventSubscriber.started_events.select do |event|
+      get_more_events = subscriber.started_events.select do |event|
         event.command['getMore']
       end
 
       expect(get_more_events.length).to eq(1)
 
       # getMore should have been sent on the same connection as find
-      connection_created_events = EventSubscriber.published_events.select do |event|
+      connection_created_events = subscriber.published_events.select do |event|
         event.is_a?(Mongo::Monitoring::Event::Cmap::ConnectionCreated)
       end
       expect(connection_created_events).to be_empty
@@ -131,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
@@ -155,13 +162,17 @@ describe 'Step down behavior' do
       let(:fail_point_code) { 10107 }
 
       it 'keeps connection open' do
-        event_subscriber.clear_events!
+        subscriber.clear_events!
 
         expect do
           collection.insert_one(test: 1)
         end.to raise_error(Mongo::Error::OperationFailure, /10107/)
 
-        expect(event_subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(0)
+        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
 
@@ -174,13 +185,17 @@ describe 'Step down behavior' do
       let(:fail_point_code) { 10107 }
 
       it 'closes the connection' do
-        event_subscriber.clear_events!
+        subscriber.clear_events!
 
         expect do
           collection.insert_one(test: 1)
         end.to raise_error(Mongo::Error::OperationFailure, /10107/)
 
-        expect(event_subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
+        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
 
@@ -191,13 +206,17 @@ describe 'Step down behavior' do
       let(:fail_point_code) { 11600 }
 
       it 'closes the connection' do
-        event_subscriber.clear_events!
+        subscriber.clear_events!
 
         expect do
           collection.insert_one(test: 1)
         end.to raise_error(Mongo::Error::OperationFailure, /11600/)
 
-        expect(event_subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared).count).to eq(1)
+        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/time_zone_querying_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Time zone querying' do

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

data/spec/integration/transactions_api_examples_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Transactions API examples' do
+  require_wired_tiger
+  require_transaction_support
+
+  # Until https://jira.mongodb.org/browse/RUBY-1768 is implemented, limit
+  # the tests to simple configurations
+  require_no_auth
+  require_no_tls
+
+  let(:uri_string) do
+    "mongodb://#{SpecConfig.instance.addresses.join(',')}"
+  end
+
+  it 'with_transaction API example 1' do
+
+    # Start Transactions withTxn API Example 1
+
+    # For a replica set, include the replica set name and a seedlist of the members in the URI string; e.g.
+    # uriString = 'mongodb://mongodb0.example.com:27017,mongodb1.example.com:27017/?replicaSet=myRepl'
+    # For a sharded cluster, connect to the mongos instances; e.g.
+    # uri_string = 'mongodb://mongos0.example.com:27017,mongos1.example.com:27017/'
+
+    client = Mongo::Client.new(uri_string, write_concern: {w: :majority, wtimeout: 1000})
+
+    # Prereq: Create collections.
+
+    client.use('mydb1')['foo'].insert_one(abc: 0)
+    client.use('mydb2')['bar'].insert_one(xyz: 0)
+
+    # Step 1: Define the callback that specifies the sequence of operations to perform inside the transactions.
+
+    callback = Proc.new do |my_session|
+      collection_one = client.use('mydb1')['foo']
+      collection_two = client.use('mydb2')['bar']
+
+      # Important: You must pass the session to the operations.
+
+      collection_one.insert_one({'abc': 1}, session: my_session)
+      collection_two.insert_one({'xyz': 999}, session: my_session)
+    end
+
+    #. Step 2: Start a client session.
+
+    session = client.start_session
+
+    # Step 3: Use with_transaction to start a transaction, execute the callback, and commit (or abort on error).
+
+    session.with_transaction(
+      read_concern: {level: :local},
+      write_concern: {w: :majority, wtimeout: 1000},
+      read: {mode: :primary},
+      &callback)
+
+    # End Transactions withTxn API Example 1
+
+  end
+end

data/spec/integration/transactions_examples_spec.rb

@@ -1,31 +1,54 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Transactions examples' do
   require_wired_tiger
   require_transaction_support
 
+  let(:client) do
+    authorized_client.with(read_concern: {level: :majority}, write: {w: :majority})
+  end
+
+  before do
+    if SpecConfig.instance.client_debug?
+      Mongo::Logger.logger.level = 0
+    end
+  end
+
   let(:hr) do
-    authorized_client.use(:hr).database
+    client.use(:hr).database
   end
 
   let(:reporting) do
-    authorized_client.use(:reporting).database
+    client.use(:reporting).database
   end
 
   before(:each) do
     hr[:employees].insert_one(employee: 3, status: 'Active')
+
+    # Sanity check since this test likes to fail
+    employee = hr[:employees].find({ employee: 3 }, limit: 1).first
+    expect(employee).to_not be_nil
+
     reporting[:events].insert_one(employee: 3, status: { new: 'Active', old: nil})
   end
 
   after(:each) do
     hr.drop
     reporting.drop
+
+    # Work around https://jira.mongodb.org/browse/SERVER-53015
+    ::Utils.mongos_each_direct_client do |client|
+      client.database.command(flushRouterConfig: 1)
+    end
   end
 
   context 'individual examples' do
 
     let(:session) do
-      authorized_client.start_session
+      client.start_session
     end
 
     # Start Transactions Intro Example 1
@@ -142,10 +165,6 @@ describe 'Transactions examples' do
 
   context 'Transactions Retry Example 3 (combined example)' do
 
-    let(:client) do
-      authorized_client
-    end
-
     let(:run_transaction) do
 
       # Start Transactions Retry Example 3
@@ -183,7 +202,8 @@ describe 'Transactions examples' do
         events_coll = session.client.use(:reporting)[:events]
 
         session.start_transaction(read_concern: { level: :snapshot },
-                                  write_concern: { w: :majority })
+                                  write_concern: { w: :majority },
+                                  read: {mode: :primary})
         employees_coll.update_one({ employee: 3 }, { '$set' => { status: 'Inactive'} },
                                   session: session)
         events_coll.insert_one({ employee: 3, status: { new: 'Inactive', old: 'Active' } },
@@ -194,7 +214,9 @@ describe 'Transactions examples' do
       session = client.start_session
 
       begin
-        run_transaction_with_retry(session) { |s| update_employee_info(s) }
+        run_transaction_with_retry(session) do
+          update_employee_info(session)
+        end
       rescue StandardError => e
         # Do something with error
         raise

data/spec/integration/truncated_utf8_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'truncated UTF-8 in server error messages' do
+  let(:rep) do
+    '(╯°□°)╯︵ ┻━┻'
+  end
+
+  let(:collection) do
+    authorized_client['truncated_utf8']
+  end
+
+  before(:all) do
+    ClientRegistry.instance.global_client('authorized')['truncated_utf8'].indexes.create_one(
+      {k: 1}, unique: true)
+  end
+
+  it 'works' do
+    pending 'RUBY-2560'
+
+    collection.insert_one(k: rep*20)
+    collection.insert_one(k: rep*20)
+  end
+end

data/spec/integration/versioned_api_examples_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Versioned API examples' do
+
+  # Until https://jira.mongodb.org/browse/RUBY-1768 is implemented, limit
+  # 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(',')}/versioned-api-examples"
+  end
+
+  it 'Versioned API example 1' do
+
+    # Start Versioned API Example 1
+
+    client = Mongo::Client.new(uri_string, server_api: {version: "1"})
+
+    # End Versioned API Example 1
+
+    # Run a command to ensure the client works.
+    client['test'].find.to_a.should be_a(Array)
+    # Do not leak clients.
+    client.close
+  end
+
+  it 'Versioned API example 2' do
+    # Start Versioned API Example 2
+
+    client = Mongo::Client.new(uri_string, server_api: {version: "1", strict: true})
+
+    # End Versioned API Example 2
+
+    # Run a command to ensure the client works.
+    client['test'].find.to_a.should be_a(Array)
+    # Do not leak clients.
+    client.close
+  end
+
+  it 'Versioned API example 3' do
+    # Start Versioned API Example 3
+
+    client = Mongo::Client.new(uri_string, server_api: {version: "1", strict: false})
+
+    # End Versioned API Example 3
+
+    # Run a command to ensure the client works.
+    client['test'].find.to_a.should be_a(Array)
+    # Do not leak clients.
+    client.close
+  end
+
+  it 'Versioned API example 4' do
+    # Start Versioned API Example 4
+
+    client = Mongo::Client.new(uri_string, server_api: {version: "1", deprecation_errors: true})
+
+    # End Versioned API Example 4
+
+    # Run a command to ensure the client works.
+    client['test'].find.to_a.should be_a(Array)
+    # Do not leak clients.
+    client.close
+  end
+
+  # 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'
+
+    it "Versioned API Strict Migration Example" do
+      client = Mongo::Client.new(uri_string, server_api: {version: "1", strict: true})
+      client[:sales].drop
+
+      # Start 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") }
+      ])
+
+      # End Versioned API Example 5
+
+      expect do
+        client.database.command(count: :sales)
+      end.to raise_error(Mongo::Error::OperationFailure)
+
+      # Start 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
+
+      # End Versioned API Example 6
+
+      # Start Versioned API Example 7
+
+      client[:sales].count_documents
+
+      # End Versioned API Example 7
+
+      # Start Versioned API Example 8
+
+      # 8
+
+      # End Versioned API Example 8
+      # Do not leak clients.
+      client.close
+    end
+  end
+end