mongo 2.20.1 → 2.21.1

data/spec/USERS.md

@@ -1,72 +0,0 @@
-# Test Users
-
-The Mongo Ruby Driver tests assume the presence of two `Mongo::Auth::User` objects:
-`root_user` and `test_user`. This document details the roles and privileges granted
-to those users as well as how they are created and used in the tests.
-
-Both users are defined in the [spec_config](support/spec_config.rb#L376) file.
-
-## root_user
-`root_user` is the test user with the most privileges. It is created with the following roles:
-- userAdminAnyDatabase
-- dbAdminAnyDatabase
-- readWriteAnyDatabase
-- clusterAdmin
-
-By default, `root_user` is given a username of `root-user` and a password of `password`.
-However, you may override these defaults by specifying a username and password in the
-`MONGODB_URI` environment variable while running your tests. For example, if you set `MONGODB_URI` to: `mongodb://alanturing:enigma@localhost:27017/`, the username of `root_user` would be set to `alanturing`, and the password would be set to `enigma`.
-
-## test_user
-`test_user` is the user created with a more limited set of privileges. It is created with the following
-roles:
-- readWrite on the ruby-driver database
-- dbAdmin on the ruby-driver database
-
-It is also granted the following roles against a database called "invalid_database." These permissions are used for the purpose of running tests against a database that doesn't exist.
-- readWrite on the invalid_database database
-- dbAdmin on the invalid_database database
-
-`test_user` also has the following roles, which are exclusively used to test transactions:
-- readWrite on the hr database
-- dbAdmin on the hr database
-- readWrite on the reporting database
-- dbAdmin on the reporting database
-
-The `test_user` has the username `test-user` and the password `password`; these values are not customizable without changing the source code.
-
-## User Creation
-
-Both users are typically created in the [spec_setup](support/spec_setup.rb) script, which can be
-run in two ways: either by running `bundle exec rake spec:prepare`, which only runs spec setup without
-running any actual tests, or by running `rake`, which runs spec setup and the entire test suite.
-
-First, the `spec_setup` script attempts to create the `root_user`. If this user already exists (for example,
-if you have already created this user in your test instance), `spec_setup` will skip this step. Once
-the script has verified the existence of `root_user`, it will create a client authenticated with the `root_user` and use that client to create a second user, `test_user`. Because `root_user` has the `userAdminAnyDatabase` role, it has the permissions necessary to create and destroy users on your MongoDB instance. If you have already created a user with the same credentials as `test_user` prior to running
-the `spec_setup` script, the script will delete this user and re-create it.
-
-The `root_user` is created in the `admin` database, while the `test_user` is created in the `ruby-driver`
-database.
-
-The authentication mechanism used to store the user credentials is going to change depending on the version of MongoDB running on your deployment. If you are running tests against a MongoDB instance with a server version older than 3.0, the users will be created using the `MONGODB-CR` authentication mechanism. If your server version is between 3.0 and 3.6 (inclusive), the test users will be created using the `SCRAM-SHA-1` mechanism, which was introduced as the new default starting in MongoDB version 3.0. If you are running a version of MongoDB newer than 4.0, test users will be authenticated using either `SCRAM-SHA-1` or `SCRAM-SHA-256`.
-
-**Note:** (m-launch)[http://blog.rueckstiess.com/mtools/mlaunch.html], the client tool we use to spin up MongoDB instances for our tests, creates users EXCLUSIVELY with the `SCRAM-SHA-1` mechanism, even when `SCRAM-SHA-256` is enabled on the test server. This should not impact your ability to run the Mongo Ruby Driver test suite.
-
-## Test Usage
-
-`root_user` is used in the Mongo Ruby Driver tests to perform functionality that requires its high-level
-roles and privileges (if your client is set up with authentication), such as creating and destroying users and database administration. To easily set up a `Mongo::Client` object authenticated with the roles and privileges of `root_user`, you can initialize a client using the `ClientRegistry` module as follows:
-
-```
-client = ClientRegistry.instance.global_client('root_authorized')
-```
-
-Of course, not every test will require you to create a client with so many privileges. Often, it is enough
-to have a user who is only authorized to read and write to a specific test database. In this case, it is preferable to use `test_user`. To initialize a `Mongo::Client` object authenticated with the `test_user` object, use the `ClientRegistry` module as follows:
-
-```
-client = ClientRegistry.instance.global_client('authorized')
-```
-
-Once you have initialized these client objects, you may use them to perform functionality required by your tests.

data/spec/atlas/atlas_connectivity_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'lite_spec_helper'
-
-describe 'Atlas connectivity' do
-  let(:uri) { ENV['ATLAS_URI'] }
-  let(:client) { Mongo::Client.new(uri) }
-
-  require_atlas
-
-  describe 'connection to Atlas' do
-    it 'runs ismaster successfully' do
-      expect { client.database.command(:hello => 1) }
-        .not_to raise_error
-    end
-
-    it 'runs findOne successfully' do
-      expect { client.use(:test)['test'].find.to_a }
-        .not_to raise_error
-    end
-  end
-end

data/spec/atlas/operations_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'lite_spec_helper'
-
-describe 'Operations' do
-  let(:uri) { ENV['ATLAS_URI'] }
-  let(:client) { Mongo::Client.new(uri) }
-
-  require_atlas
-
-  describe 'ping' do
-    it 'works' do
-      expect do
-        client.database.command(ping: 1)
-      end.not_to raise_error
-    end
-  end
-end

data/spec/faas/ruby-sam-app/Gemfile

@@ -1,9 +0,0 @@
-source "https://rubygems.org"
-
-gem "httparty"
-gem "mongo"
-
-group :test do
-  gem "test-unit"
-  gem "mocha"
-end

data/spec/faas/ruby-sam-app/mongodb/Gemfile

@@ -1,4 +0,0 @@
-source "https://rubygems.org"
-
-gem "httparty"
-gem "mongo"

data/spec/faas/ruby-sam-app/mongodb/app.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-require 'mongo'
-require 'json'
-
-class StatsAggregator
-
-  def initialize
-    @open_connections = 0
-    @heartbeats_count = 0
-    @total_heartbeat_time = 0
-    @commands_count = 0
-    @total_command_time = 0
-  end
-
-  def add_command(duration)
-    @commands_count += 1
-    @total_command_time += duration
-  end
-
-  def add_heartbeat(duration)
-    @heartbeats_count += 1
-    @total_heartbeat_time += duration
-  end
-
-  def add_connection
-    @open_connections += 1
-  end
-
-  def remove_connection
-    @open_connections -= 1
-  end
-
-  def average_heartbeat_time
-    if @heartbeats_count == 0
-      0
-    else
-      @total_heartbeat_time / @heartbeats_count
-    end
-  end
-
-  def average_command_time
-    if @commands_count == 0
-      0
-    else
-      @total_command_time / @commands_count
-    end
-  end
-
-  def reset
-    @open_connections = 0
-    @heartbeats_count = 0
-    @total_heartbeat_time = 0
-    @commands_count = 0
-    @total_command_time = 0
-  end
-
-  def result
-    {
-      average_heartbeat_time: average_heartbeat_time,
-      average_command_time: average_command_time,
-      heartbeats_count: @heartbeats_count,
-      open_connections: @open_connections,
-    }
-  end
-end
-
-class CommandMonitor
-
-  def initialize(stats_aggregator)
-    @stats_aggregator = stats_aggregator
-  end
-
-  def started(event); end
-
-  def failed(event)
-    @stats_aggregator.add_command(event.duration)
-  end
-
-  def succeeded(event)
-    @stats_aggregator.add_command(event.duration)
-  end
-end
-
-class HeartbeatMonitor
-
-  def initialize(stats_aggregator)
-    @stats_aggregator = stats_aggregator
-  end
-
-  def started(event); end
-
-  def succeeded(event)
-    @stats_aggregator.add_heartbeat(event.duration)
-  end
-
-  def failed(event)
-    @stats_aggregator.add_heartbeat(event.duration)
-  end
-end
-
-class PoolMonitor
-
-  def initialize(stats_aggregator)
-    @stats_aggregator = stats_aggregator
-  end
-
-  def published(event)
-    case event
-    when Mongo::Monitoring::Event::Cmap::ConnectionCreated
-      @stats_aggregator.add_connection
-    when Mongo::Monitoring::Event::Cmap::ConnectionClosed
-      @stats_aggregator.remove_connection
-    end
-  end
-end
-
-$stats_aggregator = StatsAggregator.new
-
-command_monitor = CommandMonitor.new($stats_aggregator)
-heartbeat_monitor = HeartbeatMonitor.new($stats_aggregator)
-pool_monitor = PoolMonitor.new($stats_aggregator)
-
-sdam_proc = proc do |client|
-  client.subscribe(Mongo::Monitoring::COMMAND, command_monitor)
-  client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, heartbeat_monitor)
-  client.subscribe(Mongo::Monitoring::CONNECTION_POOL, pool_monitor)
-end
-
-puts 'Connecting'
-$client = Mongo::Client.new(ENV['MONGODB_URI'], sdam_proc: sdam_proc)
-# Populate the connection pool
-$client.use('lambda_test').database.list_collections
-puts 'Connected'
-
-def lambda_handler(event:, context:)
-  db = $client.use('lambda_test')
-  collection = db[:test_collection]
-  result = collection.insert_one({ name: 'test' })
-  collection.delete_one({ _id: result.inserted_id })
-  response = $stats_aggregator.result.to_json
-  $stats_aggregator.reset
-  puts "Response: #{response}"
-
-  {
-    statusCode: 200,
-    body: response
-  }
-end

data/spec/faas/ruby-sam-app/template.yaml

@@ -1,48 +0,0 @@
-AWSTemplateFormatVersion: '2010-09-09'
-Transform: AWS::Serverless-2016-10-31
-Description: >
-  Sample SAM Template for ruby-sam-app
-
-# More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
-Globals:
-  Function:
-    Timeout: 30
-    MemorySize: 128
-
-Parameters:
-  MongoDbUri:
-    Type: String
-    Description: The MongoDB connection string.
-
-Resources:
-  MongoDBFunction:
-    Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
-    Properties:
-      CodeUri: mongodb/
-      Environment:
-        Variables:
-          MONGODB_URI: !Ref MongoDbUri
-      Handler: app.lambda_handler
-      Runtime: ruby3.2
-      Architectures:
-        - x86_64
-      Events:
-        MongoDB:
-          Type: Api # More info about API Event Source: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
-          Properties:
-            Path: /mongodb
-            Method: get
-
-Outputs:
-  # ServerlessRestApi is an implicit API created out of Events key under Serverless::Function
-  # Find out more about other implicit resources you can reference within SAM
-  # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
-  MongoDBApi:
-    Description: "API Gateway endpoint URL for Prod stage for MongoDB function"
-    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/mongodb/"
-  MongoDBFunction:
-    Description: "MongoDB Lambda Function ARN"
-    Value: !GetAtt MongoDBFunction.Arn
-  MongoDBFunctionIamRole:
-    Description: "Implicit IAM Role created for MongoDB function"
-    Value: !GetAtt MongoDBFunctionRole.Arn

data/spec/integration/auth_spec.rb

@@ -1,309 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'spec_helper'
-
-describe 'Auth' do
-  # User creation with a password fails on the server if, for example,
-  # only MONGODB-AWS auth mechanism is allowed in server configuration.
-  require_no_external_user
-
-  describe 'Unauthorized exception message' do
-    let(:server) do
-      authorized_client.cluster.next_primary
-    end
-
-    let(:base_options) do
-      SpecConfig.instance.monitoring_options.merge(connect: SpecConfig.instance.test_options[:connect])
-    end
-
-    let(:connection) do
-      Mongo::Server::Connection.new(server, base_options.merge(options))
-    end
-
-    before(:all) do
-      # If auth is configured, the test suite uses the configured user
-      # and does not create its own users. However, the configured user may
-      # not have the auth mechanisms we need. Therefore we create a user
-      # for this test without specifying auth mechanisms, which gets us
-      # server default (scram for 4.0, scram & scram256 for 4.2).
-
-      users = ClientRegistry.instance.global_client('root_authorized').use(:admin).database.users
-      unless users.info('existing_user').empty?
-        users.remove('existing_user')
-      end
-      users.create('existing_user', password: 'password')
-    end
-
-    context 'user mechanism not provided' do
-
-      context 'user does not exist' do
-        let(:options) do
-          {user: 'nonexistent_user' }
-        end
-
-        before do
-          expect(connection.app_metadata.send(:document)[:saslSupportedMechs]).to eq('admin.nonexistent_user')
-        end
-
-        context 'scram-sha-1 only server' do
-          min_server_fcv '3.0'
-          max_server_version '3.6'
-
-          it 'indicates scram-sha-1 was used' do
-            expect do
-              connection.connect!
-            end.to raise_error(Mongo::Auth::Unauthorized, /User nonexistent_user \(mechanism: scram\) is not authorized to access admin.*used mechanism: SCRAM-SHA-1/)
-          end
-        end
-
-        context 'scram-sha-256 server' do
-          min_server_fcv '4.0'
-
-          # An existing user on 4.0+ will negotiate scram-sha-256.
-          # A non-existing user on 4.0+ will negotiate scram-sha-1.
-          it 'indicates scram-sha-1 was used' do
-            expect do
-              connection.connect!
-            end.to raise_error(Mongo::Auth::Unauthorized, /User nonexistent_user \(mechanism: scram\) is not authorized to access admin.*used mechanism: SCRAM-SHA-1/)
-          end
-        end
-      end
-
-      context 'user exists' do
-        let(:options) do
-          {user: 'existing_user', password: 'bogus'}
-        end
-
-        before do
-          expect(connection.app_metadata.send(:document)[:saslSupportedMechs]).to eq("admin.existing_user")
-        end
-
-        context 'scram-sha-1 only server' do
-          min_server_fcv '3.0'
-          max_server_version '3.6'
-
-          it 'indicates scram-sha-1 was used' do
-            expect do
-              connection.connect!
-            end.to raise_error(Mongo::Auth::Unauthorized, /User existing_user \(mechanism: scram\) is not authorized to access admin.*used mechanism: SCRAM-SHA-1/)
-          end
-        end
-
-        context 'scram-sha-256 server' do
-          min_server_fcv '4.0'
-
-          # An existing user on 4.0+ will negotiate scram-sha-256.
-          # A non-existing user on 4.0+ will negotiate scram-sha-1.
-          it 'indicates scram-sha-256 was used' do
-            expect do
-              connection.connect!
-            end.to raise_error(Mongo::Auth::Unauthorized, /User existing_user \(mechanism: scram256\) is not authorized to access admin.*used mechanism: SCRAM-SHA-256/)
-          end
-        end
-      end
-    end
-
-    context 'user mechanism is provided' do
-      min_server_fcv '3.0'
-
-      context 'scram-sha-1 requested' do
-        let(:options) do
-          {user: 'nonexistent_user', auth_mech: :scram}
-        end
-
-        it 'indicates scram-sha-1 was requested and used' do
-          expect do
-            connection.connect!
-          end.to raise_error(Mongo::Auth::Unauthorized, /User nonexistent_user \(mechanism: scram\) is not authorized to access admin.*used mechanism: SCRAM-SHA-1/)
-        end
-      end
-
-      context 'scram-sha-256 requested' do
-        min_server_fcv '4.0'
-
-        let(:options) do
-          {user: 'nonexistent_user', auth_mech: :scram256}
-        end
-
-        it 'indicates scram-sha-256 was requested and used' do
-          expect do
-            connection.connect!
-          end.to raise_error(Mongo::Auth::Unauthorized, /User nonexistent_user \(mechanism: scram256\) is not authorized to access admin.*used mechanism: SCRAM-SHA-256/)
-        end
-      end
-    end
-
-    context 'when authentication fails' do
-      let(:options) do
-        {user: 'nonexistent_user', password: 'foo'}
-      end
-
-      it 'reports which server authentication was attempted against' do
-        expect do
-          connection.connect!
-        end.to raise_error(Mongo::Auth::Unauthorized, /used server: #{connection.address.to_s}/)
-      end
-
-      context 'with default auth source' do
-        it 'reports auth source used' do
-          expect do
-            connection.connect!
-          end.to raise_error(Mongo::Auth::Unauthorized, /auth source: admin/)
-        end
-      end
-
-      context 'with custom auth source' do
-        let(:options) do
-          {user: 'nonexistent_user', password: 'foo', auth_source: 'authdb'}
-        end
-
-        it 'reports auth source used' do
-          expect do
-            connection.connect!
-          end.to raise_error(Mongo::Auth::Unauthorized, /auth source: authdb/)
-        end
-      end
-    end
-
-    context 'attempting to connect to a non-tls server with tls' do
-      require_no_tls
-      # The exception raised is SocketTimeout on 3.6 server for whatever reason,
-      # run the test on 4.0+ only.
-      min_server_fcv '4.0'
-
-      let(:options) { {ssl: true} }
-
-      it 'reports host, port and tls status' do
-        begin
-          connection.connect!
-        rescue Mongo::Error::SocketError => exc
-        end
-        expect(exc).not_to be nil
-        expect(exc.message).to include('OpenSSL::SSL::SSLError')
-        expect(exc.message).to include(server.address.to_s)
-        expect(exc.message).to include('TLS')
-        expect(exc.message).not_to include('no TLS')
-      end
-    end
-
-    context 'attempting to connect to a tls server without tls' do
-      require_tls
-
-      let(:options) { {ssl: false} }
-
-      it 'reports host, port and tls status' do
-        begin
-          connection.connect!
-        rescue Mongo::Error::SocketError => exc
-        end
-        expect(exc).not_to be nil
-        expect(exc.message).not_to include('OpenSSL::SSL::SSLError')
-        addresses = Socket.getaddrinfo(server.address.host, nil)
-        expect(addresses.any? do |address|
-          exc.message.include?("#{address[2]}:#{server.address.port}")
-        end).to be true
-        expect(exc.message).to include('no TLS')
-      end
-    end
-  end
-
-  shared_examples_for 'caches client key' do
-    it 'caches' do
-      client.close
-      Mongo::Auth::CredentialCache.clear
-
-      RSpec::Mocks.with_temporary_scope do
-        expect_any_instance_of(conversation_class).to receive(:hi).exactly(:once).and_call_original
-
-        client.reconnect
-        server = client.cluster.next_primary
-        server.with_connection do
-          server.with_connection do
-            # nothing
-          end
-        end
-      end
-    end
-  end
-
-  describe 'scram-sha-1 client key caching' do
-    clean_slate
-    min_server_version '3.0'
-    require_no_external_user
-
-    let(:client) { authorized_client.with(max_pool_size: 2, auth_mech: :scram) }
-    let(:conversation_class) { Mongo::Auth::Scram::Conversation }
-
-    it_behaves_like 'caches client key'
-  end
-
-  describe 'scram-sha-256 client key caching' do
-    clean_slate
-    min_server_version '4.0'
-    require_no_external_user
-
-    let(:client) { authorized_client.with(max_pool_size: 2, auth_mech: :scram256) }
-    let(:conversation_class) { Mongo::Auth::Scram256::Conversation }
-
-    it_behaves_like 'caches client key'
-  end
-
-  context 'when only auth source is specified' do
-    require_no_auth
-
-    let(:client) do
-      new_local_client(SpecConfig.instance.addresses, SpecConfig.instance.monitoring_options.merge(
-        auth_source: 'foo'))
-    end
-
-    it 'does not authenticate' do
-      expect(Mongo::Auth::User).not_to receive(:new)
-      client.database.command(ping: 1)
-    end
-  end
-
-  context 'when only auth mechanism is specified' do
-    require_x509_auth
-
-    let(:client) do
-      new_local_client(SpecConfig.instance.addresses, base_options.merge(
-        auth_mech: :mongodb_x509))
-    end
-
-    it 'authenticates' do
-      expect(Mongo::Auth::User).to receive(:new).and_call_original
-      client.database.command(ping: 1)
-    end
-  end
-
-  context 'in lb topology' do
-    require_topology :load_balanced
-
-    context 'when authentication fails with network error' do
-      let(:server) do
-        authorized_client.cluster.next_primary
-      end
-
-      let(:base_options) do
-        SpecConfig.instance.monitoring_options.merge(connect: SpecConfig.instance.test_options[:connect])
-      end
-
-      let(:connection) do
-        Mongo::Server::Connection.new(server, base_options)
-      end
-
-      it 'includes service id in exception' do
-        expect_any_instance_of(Mongo::Server::PendingConnection).to receive(:authenticate!).and_raise(Mongo::Error::SocketError)
-
-        begin
-          connection.connect!
-        rescue Mongo::Error::SocketError => exc
-          exc.service_id.should_not be nil
-        else
-          fail 'Expected the SocketError to be raised'
-        end
-      end
-    end
-  end
-end

data/spec/integration/awaited_ismaster_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'spec_helper'
-
-describe 'awaited hello' do
-  min_server_fcv '4.4'
-
-  # If we send the consecutive hello commands to different mongoses,
-  # they have different process ids, and so the awaited one would return
-  # immediately.
-  require_no_multi_mongos
-
-  let(:client) { authorized_client }
-
-  it 'waits' do
-    # Perform a regular hello to get topology version
-    resp = client.database.command(hello: 1)
-    doc = resp.replies.first.documents.first
-    tv = Mongo::TopologyVersion.new(doc['topologyVersion'])
-    tv.should be_a(BSON::Document)
-
-    elapsed_time = Benchmark.realtime do
-      resp = client.database.command(hello: 1,
-        topologyVersion: tv.to_doc, maxAwaitTimeMS: 500)
-    end
-    doc = resp.replies.first.documents.first
-
-    elapsed_time.should > 0.5
-  end
-end