mongo 2.17.4 → 2.21.0

data/spec/integration/sdam_error_handling_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -8,6 +8,8 @@ describe 'SDAM error handling' do
 
   clean_slate
 
+  retry_test
+
   after do
     # Close all clients after every test to avoid leaking expectations into
     # subsequent tests because we set global assertions on sockets.
@@ -25,6 +27,7 @@ describe 'SDAM error handling' do
       SpecConfig.instance.all_test_options.merge(
         socket_timeout: 3, connect_timeout: 3,
         heartbeat_frequency: 100,
+        populator_io: false,
         # Uncomment to print all events to stdout:
         #sdam_proc: Utils.subscribe_all_sdam_proc(diagnostic_subscriber),
         **Utils.disable_retries_client_options)
@@ -92,7 +95,7 @@ describe 'SDAM error handling' do
       generation = server.pool.generation
       RSpec::Mocks.with_temporary_scope do
         operation
-        new_generation = server.pool.generation
+        new_generation = server.pool_internal.generation
         expect(new_generation).to eq(generation + 1)
       end
     end
@@ -103,7 +106,7 @@ describe 'SDAM error handling' do
       generation = server.pool.generation
       RSpec::Mocks.with_temporary_scope do
         operation
-        new_generation = server.pool.generation
+        new_generation = server.pool_internal.generation
         expect(new_generation).to eq(generation)
       end
     end
@@ -248,12 +251,13 @@ describe 'SDAM error handling' do
 
         it 'marks server unknown' do
           server = client.cluster.next_primary
+          pool = client.cluster.pool(server)
           client.cluster.servers.map(&:disconnect!)
 
           RSpec::Mocks.with_temporary_scope do
 
             Socket.should receive(:new).with(any_args).ordered.once.and_return(socket)
-
+            allow(pool).to receive(:paused?).and_return(false)
             lambda do
               client.command(ping: 1)
             end.should raise_error(mapped_error_cls, /mocked failure/)
@@ -416,11 +420,71 @@ describe 'SDAM error handling' do
         expect_server_state_change
       end
 
-      it_behaves_like 'marks server unknown and clears connection pool'
+      # https://jira.mongodb.org/browse/RUBY-2523
+      # it_behaves_like 'marks server unknown and clears connection pool'
 
       after do
         admin_client.command(configureFailPoint: 'failCommand', mode: 'off')
       end
     end
   end
+
+  context "when there is an error on the handshake" do
+    # require appName for fail point
+    min_server_version "4.9"
+
+    let(:admin_client) do
+      new_local_client(
+        [SpecConfig.instance.addresses.first],
+        SpecConfig.instance.test_options.merge({
+          connect: :direct,
+          populator_io: false,
+          direct_connection: true,
+          app_name: "SDAMMinHeartbeatFrequencyTest",
+          database: 'admin'
+        })
+      )
+    end
+
+    let(:cmd_client) do
+      # Change the server selection timeout so that we are given a new cluster.
+      admin_client.with(server_selection_timeout: 5)
+    end
+
+    let(:set_fail_point) do
+      admin_client.command(
+        configureFailPoint: 'failCommand',
+        mode: { times: 5 },
+        data: {
+          failCommands: %w(isMaster hello),
+          errorCode: 1234,
+          appName: "SDAMMinHeartbeatFrequencyTest"
+        },
+      )
+    end
+
+    let(:operation) do
+      expect(server.monitor.connection).not_to be nil
+      set_fail_point
+    end
+
+    it "waits 500ms between failed hello checks" do
+      operation
+      start = Mongo::Utils.monotonic_time
+      cmd_client.command(hello: 1)
+      duration = Mongo::Utils.monotonic_time - start
+      expect(duration).to be >= 2
+      expect(duration).to be <= 3.5
+
+      # The cluster that we use to set up the failpoint should not be the same
+      # one we ping on, so that the ping will have to select a server. The admin
+      # client has already selected a server.
+      expect(admin_client.cluster.object_id).to_not eq(cmd_client.cluster.object_id)
+    end
+
+    after do
+      admin_client.command(configureFailPoint: 'failCommand', mode: 'off')
+      cmd_client.close
+    end
+  end
 end

data/spec/integration/sdam_events_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/sdam_prose_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -47,12 +47,12 @@ describe 'SDAM prose tests' do
         },
       )
 
-      deadline = Time.now + 10
+      deadline = Mongo::Utils.monotonic_time + 10
       loop do
         if server.average_round_trip_time > 0.25
           break
         end
-        if Time.now >= deadline
+        if Mongo::Utils.monotonic_time >= deadline
           raise "Failed to witness RTT growing to >= 250 ms in 10 seconds"
         end
         sleep 0.2

data/spec/integration/search_indexes_prose_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class SearchIndexHelper
+  attr_reader :client, :collection_name
+
+  def initialize(client)
+    @client = client
+
+    # https://github.com/mongodb/specifications/blob/master/source/index-management/tests/README.rst#id4
+    # "...each test uses a randomly generated collection name.  Drivers may
+    # generate this collection name however they like, but a suggested
+    # implementation is a hex representation of an ObjectId..."
+    @collection_name = BSON::ObjectId.new.to_s
+  end
+
+  # `soft_create` means to create the collection object without forcing it to
+  # be created in the database.
+  def collection(soft_create: false)
+    @collection ||= client.database[collection_name].tap do |collection|
+      collection.create unless soft_create
+    end
+  end
+
+  # Wait for all of the indexes with the given names to be ready; then return
+  # the list of index definitions corresponding to those names.
+  def wait_for(*names, &condition)
+    timeboxed_wait do
+      result = collection.search_indexes
+      return filter_results(result, names) if names.all? { |name| ready?(result, name, &condition) }
+    end
+  end
+
+  # Wait until all of the indexes with the given names are absent from the
+  # search index list.
+  def wait_for_absense_of(*names)
+    names.each do |name|
+      timeboxed_wait do
+        break if collection.search_indexes(name: name).empty?
+      end
+    end
+  end
+
+  private
+
+  def timeboxed_wait(step: 5, max: 300)
+    start = Mongo::Utils.monotonic_time
+
+    loop do
+      yield
+
+      sleep step
+      raise Timeout::Error, 'wait took too long' if Mongo::Utils.monotonic_time - start > max
+    end
+  end
+
+  # Returns true if the list of search indexes includes one with the given name,
+  # which is ready to be queried.
+  def ready?(list, name, &condition)
+    condition ||= ->(index) { index['queryable'] }
+    list.any? { |index| index['name'] == name && condition[index] }
+  end
+
+  def filter_results(result, names)
+    result.select { |index| names.include?(index['name']) }
+  end
+end
+
+describe 'Mongo::Collection#search_indexes prose tests' do
+  # https://github.com/mongodb/specifications/blob/master/source/index-management/tests/README.rst#id5
+  # "These tests must run against an Atlas cluster with a 7.0+ server."
+  require_atlas
+
+  let(:client) do
+    Mongo::Client.new(
+      ENV['ATLAS_URI'],
+      database: SpecConfig.instance.test_db,
+      ssl: true,
+      ssl_verify: true
+    )
+  end
+
+  let(:helper) { SearchIndexHelper.new(client) }
+
+  let(:name) { 'test-search-index' }
+  let(:definition) { { 'mappings' => { 'dynamic' => false } } }
+  let(:create_index) { helper.collection.search_indexes.create_one(definition, name: name) }
+
+  after do
+    client.close
+  end
+
+  # Case 1: Driver can successfully create and list search indexes
+  context 'when creating and listing search indexes' do
+    let(:index) { helper.wait_for(name).first }
+
+    it 'succeeds' do
+      expect(create_index).to be == name
+      expect(index['latestDefinition']).to be == definition
+    end
+  end
+
+  # Case 2: Driver can successfully create multiple indexes in batch
+  context 'when creating multiple indexes in batch' do
+    let(:specs) do
+      [
+        { 'name' => 'test-search-index-1', 'definition' => definition },
+        { 'name' => 'test-search-index-2', 'definition' => definition }
+      ]
+    end
+
+    let(:names) { specs.map { |spec| spec['name'] } }
+    let(:create_indexes) { helper.collection.search_indexes.create_many(specs) }
+
+    let(:indexes) { helper.wait_for(*names) }
+
+    let(:index1) { indexes[0] }
+    let(:index2) { indexes[1] }
+
+    it 'succeeds' do
+      expect(create_indexes).to be == names
+      expect(index1['latestDefinition']).to be == specs[0]['definition']
+      expect(index2['latestDefinition']).to be == specs[1]['definition']
+    end
+  end
+
+  # Case 3: Driver can successfully drop search indexes
+  context 'when dropping search indexes' do
+    it 'succeeds' do
+      expect(create_index).to be == name
+      helper.wait_for(name)
+
+      helper.collection.search_indexes.drop_one(name: name)
+
+      expect { helper.wait_for_absense_of(name) }.not_to raise_error
+    end
+  end
+
+  # Case 4: Driver can update a search index
+  context 'when updating search indexes' do
+    let(:new_definition) { { 'mappings' => { 'dynamic' => true } } }
+
+    let(:index) do
+      helper
+        .wait_for(name) { |idx| idx['queryable'] && idx['status'] == 'READY' }
+        .first
+    end
+
+    # rubocop:disable RSpec/ExampleLength
+    it 'succeeds' do
+      expect(create_index).to be == name
+      helper.wait_for(name)
+
+      expect do
+        helper.collection.search_indexes.update_one(new_definition, name: name)
+      end.not_to raise_error
+
+      expect(index['latestDefinition']).to be == new_definition
+    end
+    # rubocop:enable RSpec/ExampleLength
+  end
+
+  # Case 5: dropSearchIndex suppresses namespace not found errors
+  context 'when dropping a non-existent search index' do
+    it 'ignores `namespace not found` errors' do
+      collection = helper.collection(soft_create: true)
+      expect { collection.search_indexes.drop_one(name: name) }
+        .not_to raise_error
+    end
+  end
+end

data/spec/integration/secondary_reads_spec.rb

@@ -1,3 +1,4 @@
+# rubocop:todo all
 require 'spec_helper'
 
 describe 'Secondary reads' do

data/spec/integration/server_description_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/server_monitor_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -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/server_selection_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/server_selector_spec.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
 describe 'Server selector' do
+  require_no_linting
+
   let(:selector) { Mongo::ServerSelector::Primary.new }
   let(:client) { authorized_client }
   let(:cluster) { client.cluster }
@@ -29,11 +31,11 @@ describe 'Server selector' do
       end
 
       it 'does not wait for server selection timeout' do
-        start_time = Time.now
+        start_time = Mongo::Utils.monotonic_time
         expect do
           result
         end.to raise_error(Mongo::Error::NoServerAvailable)
-        time_passed = Time.now - start_time
+        time_passed = Mongo::Utils.monotonic_time - start_time
         expect(time_passed).to be < 1
       end
     end

data/spec/integration/server_spec.rb

@@ -1,39 +1,49 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
 describe 'Server' do
   let(:client) { authorized_client }
 
+  let(:context) { Mongo::Operation::Context.new(client: client) }
   let(:server) { client.cluster.next_primary }
 
   let(:collection) { client['collection'] }
   let(:view) { Mongo::Collection::View.new(collection) }
 
   describe 'operations when client/cluster are disconnected' do
-    shared_examples 'it performs read operations and receives the correct result type' do
+    context 'it performs read operations and receives the correct result type' do
       context 'normal server' do
         it 'can be used for reads' do
-          result = view.send(:send_initial_query, server)
-          expect(result).to be_a(result_class)
+          result = view.send(:send_initial_query, server, context)
+          expect(result).to be_a(Mongo::Operation::Find::Result)
         end
       end
 
       context 'known server in disconnected cluster' do
+        require_topology :single, :replica_set, :sharded
+        require_no_linting
+
         before do
-          client.close
+          server.disconnect!
           expect(server).not_to be_unknown
         end
 
+        after do
+          server.close
+        end
+
         it 'can be used for reads' do
-          result = view.send(:send_initial_query, server)
-          expect(result).to be_a(result_class)
+          # See also RUBY-3102.
+          result = view.send(:send_initial_query, server, context)
+          expect(result).to be_a(Mongo::Operation::Find::Result)
         end
       end
 
       context 'unknown server in disconnected cluster' do
         require_topology :single, :replica_set, :sharded
+        require_no_linting
 
         before do
           client.close
@@ -41,29 +51,17 @@ describe 'Server' do
           expect(server).to be_unknown
         end
 
-        it 'can be used for reads' do
-          result = view.send(:send_initial_query, server)
-          expect(result).to be_a(result_class)
+        after do
+          server.close
         end
-      end
-    end
 
-    context 'for servers with FCV >= 3.4' do
-      min_server_fcv '3.2'
-
-      let(:result_class) { Mongo::Operation::Find::Result }
-
-      it_behaves_like 'it performs read operations and receives the correct result type'
-    end
-
-    context 'for servers with FCV < 3.4' do
-      # Find command was introduced in server version 3.2, so older versions should
-      # receive legacy result types.
-      max_server_fcv '3.0'
-
-      let(:result_class) { Mongo::Operation::Find::Legacy::Result }
-
-      it_behaves_like 'it performs read operations and receives the correct result type'
+        it 'is unusable' do
+          # See also RUBY-3102.
+          lambda do
+            view.send(:send_initial_query, server, context)
+          end.should raise_error(Mongo::Error::ServerNotUsable)
+        end
+      end
     end
   end
 end

data/spec/integration/shell_examples_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/size_limit_spec.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 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/snappy_compression_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/snapshot_query_examples_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+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', write_concern: { w: :majority }].delete_many
+      client['dogs', write_concern: { w: :majority }].delete_many
+
+      client['cats', write_concern: { w: :majority }].insert_one(
+        name: "Whiskers",
+        color: "white",
+        age: 10,
+        adoptable: true
+      )
+
+      client['dogs', write_concern: { w: :majority }].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
+    retry_test
+
+    before do
+      client = authorized_client.use('retail')
+      client['sales', write_concern: { w: :majority }].delete_many
+
+      client['sales', write_concern: { w: :majority }].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