mongo 2.20.1 → 2.21.1

data/spec/integration/aws_auth_credentials_cache_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'spec_helper'
-
-describe Mongo::Auth::Aws::CredentialsCache do
-  require_auth 'aws-ec2', 'aws-ecs', 'aws-web-identity'
-
-  def new_client
-    ClientRegistry.instance.new_authorized_client.tap do |client|
-      @clients << client
-    end
-  end
-
-  before do
-    @clients = []
-    described_class.instance.clear
-  end
-
-  after do
-    @clients.each(&:close)
-  end
-
-  it 'caches the credentials' do
-    client1 = new_client
-    client1['test-collection'].find.to_a
-    expect(described_class.instance.credentials).not_to be_nil
-
-    described_class.instance.credentials = Mongo::Auth::Aws::Credentials.new(
-      described_class.instance.credentials.access_key_id,
-      described_class.instance.credentials.secret_access_key,
-      described_class.instance.credentials.session_token,
-      Time.now + 60
-    )
-    client2 = new_client
-    client2['test-collection'].find.to_a
-    expect(described_class.instance.credentials).not_to be_expired
-
-    described_class.instance.credentials = Mongo::Auth::Aws::Credentials.new(
-      'bad_access_key_id',
-      described_class.instance.credentials.secret_access_key,
-      described_class.instance.credentials.session_token,
-      described_class.instance.credentials.expiration
-    )
-    client3 = new_client
-    expect { client3['test-collection'].find.to_a }.to raise_error(Mongo::Auth::Unauthorized)
-    expect(described_class.instance.credentials).to be_nil
-    expect { client3['test-collection'].find.to_a }.not_to raise_error
-    expect(described_class.instance.credentials).not_to be_nil
-  end
-end

data/spec/integration/aws_auth_request_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'lite_spec_helper'
-require 'net/http'
-
-describe Mongo::Auth::Aws::Request do
-  require_aws_auth
-
-  before(:all) do
-    if ENV['AUTH'] =~ /aws-(ec2|ecs|web)/
-      skip "This test requires explicit credentials to be provided"
-    end
-  end
-
-  let(:access_key_id) { ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_ACCESS_KEY_ID') }
-  let(:secret_access_key) { ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_SECRET_ACCESS_KEY') }
-  let(:session_token) { ENV['MONGO_RUBY_DRIVER_AWS_AUTH_SESSION_TOKEN'] }
-
-  describe '#authorization' do
-    let(:request) do
-      described_class.new(
-        access_key_id: access_key_id,
-        secret_access_key: secret_access_key,
-        session_token: session_token,
-        host: 'sts.amazonaws.com',
-        server_nonce: 'aaaaaaaaaaafake',
-      )
-    end
-
-    let(:sts_request) do
-      Net::HTTP::Post.new("https://sts.amazonaws.com").tap do |req|
-        request.headers.each do |k, v|
-          req[k] = v
-        end
-        req['authorization'] = request.authorization
-        req['accept'] = 'application/json'
-        req.body = described_class::STS_REQUEST_BODY
-      end
-    end
-
-    let(:sts_response) do
-      http = Net::HTTP.new('sts.amazonaws.com', 443)
-      http.use_ssl = true
-
-      # Uncomment to log complete request headers and the response.
-      # WARNING: do not enable this in Evergreen as this can expose real
-      # AWS credentias.
-      #http.set_debug_output(STDERR)
-
-      http.start do
-        resp = http.request(sts_request)
-      end
-    end
-
-    let(:sts_response_payload) do
-      JSON.parse(sts_response.body)
-    end
-
-    let(:result) do
-      sts_response_payload['GetCallerIdentityResponse']['GetCallerIdentityResult']
-    end
-
-    it 'is usable' do
-      # This assertion intentionally does not use payload so that if it fails,
-      # the entire response is printed for diagnostic purposes.
-      sts_response.body.should_not =~ /"Error"/
-
-      sts_response.code.should == '200'
-      result['Arn'].should =~ /^arn:aws:(iam|sts)::/
-      result['Account'].should be_a(String)
-      result['UserId'].should =~ /^A/
-
-      puts "STS request successful with ARN #{result['Arn']}"
-    end
-  end
-end

data/spec/integration/aws_credentials_retriever_spec.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'lite_spec_helper'
-require 'support/aws_utils'
-
-describe Mongo::Auth::Aws::CredentialsRetriever do
-  require_aws_auth
-
-  let(:retriever) do
-    described_class.new(user)
-  end
-
-  let(:credentials) do
-    retriever.credentials
-  end
-
-  context 'when user is not given' do
-    let(:user) do
-      Mongo::Auth::User.new(auth_mech: :aws)
-    end
-
-    before do
-      Mongo::Auth::Aws::CredentialsCache.instance.clear
-    end
-
-    shared_examples_for 'retrieves the credentials' do
-      it 'retrieves' do
-        credentials.should be_a(Mongo::Auth::Aws::Credentials)
-
-        # When user is not given, credentials retrieved are always temporary.
-        retriever.credentials.access_key_id.should =~ /^ASIA/
-        retriever.credentials.secret_access_key.should =~ /./
-        retriever.credentials.session_token.should =~ /./
-      end
-
-      let(:request) do
-        Mongo::Auth::Aws::Request.new(
-          access_key_id: credentials.access_key_id,
-          secret_access_key: credentials.secret_access_key,
-          session_token: credentials.session_token,
-          host: 'sts.amazonaws.com',
-          server_nonce: 'test',
-        )
-      end
-
-      it 'produces valid credentials' do
-        result = request.validate!
-        puts "STS request successful with ARN #{result['Arn']}"
-      end
-    end
-
-    context 'ec2 instance role' do
-      require_ec2_host
-
-      before(:all) do
-        unless ENV['AUTH'] == 'aws-ec2'
-          skip "Set AUTH=aws-ec2 in environment to run EC2 instance role tests"
-        end
-      end
-
-      context 'when instance profile is not assigned' do
-        before(:all) do
-          orchestrator = AwsUtils::Orchestrator.new(
-            region: ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_REGION'),
-            access_key_id: ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_ACCESS_KEY_ID'),
-            secret_access_key: ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_SECRET_ACCESS_KEY'),
-          )
-
-          orchestrator.clear_instance_profile(Utils.ec2_instance_id)
-          Utils.wait_for_no_instance_profile
-        end
-
-        it 'raises an error' do
-          lambda do
-            credentials
-          end.should raise_error(Mongo::Auth::Aws::CredentialsNotFound, /Could not locate AWS credentials/)
-        end
-      end
-
-      context 'when instance profile is assigned' do
-        before(:all) do
-          orchestrator = AwsUtils::Orchestrator.new(
-            region: ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_REGION'),
-            access_key_id: ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_ACCESS_KEY_ID'),
-            secret_access_key: ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_SECRET_ACCESS_KEY'),
-          )
-
-          orchestrator.set_instance_profile(Utils.ec2_instance_id,
-            instance_profile_name: nil,
-            instance_profile_arn: ENV.fetch('MONGO_RUBY_DRIVER_AWS_AUTH_INSTANCE_PROFILE_ARN'),
-          )
-          Utils.wait_for_instance_profile
-        end
-
-        it_behaves_like 'retrieves the credentials'
-      end
-    end
-
-    context 'ecs task role' do
-      before(:all) do
-        unless ENV['AUTH'] == 'aws-ecs'
-          skip "Set AUTH=aws-ecs in environment to run ECS task role tests"
-        end
-      end
-
-      it_behaves_like 'retrieves the credentials'
-    end
-
-    context 'web identity' do
-      before(:all) do
-        unless ENV['AUTH'] == 'aws-web-identity'
-          skip "Set AUTH=aws-web-identity in environment to run Wed identity tests"
-        end
-      end
-
-      context 'with AWS_ROLE_SESSION_NAME' do
-        before do
-          stub_const('ENV', ENV.to_hash.merge('AWS_ROLE_SESSION_NAME' => 'mongo-ruby-driver-test-app'))
-        end
-
-        it_behaves_like 'retrieves the credentials'
-      end
-
-      context 'without AWS_ROLE_SESSION_NAME' do
-        before do
-          env = ENV.to_hash.dup
-          env.delete('AWS_ROLE_SESSION_NAME')
-          stub_const('ENV', env)
-        end
-
-        it_behaves_like 'retrieves the credentials'
-      end
-    end
-  end
-end

data/spec/integration/aws_lambda_examples_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require "spec_helper"
-
-describe "AWS Lambda examples in Ruby" do
-
-  it "shares the client" do
-    # Start AWS Lambda Example 1
-
-    # Require the driver library.
-    require "mongo"
-
-    # Create a Mongo::Client instance.
-    # CRITICAL: You must create the client instance outside the handler
-    # so that the client can be reused across function invocations.
-    client = Mongo::Client.new(ENV.fetch("MONGODB_URI"))
-
-    def lambda_handler(event:, context:)
-      # Use the client to return the name of the configured database.
-      client.database.name
-    end
-
-    # End AWS Lambda Example 1
-
-    client.close
-  end
-
-  context "when using AWS IAM authentication" do
-    require_auth 'aws-assume-role'
-
-    it "connects to the deployment" do
-      allow(ENV).to receive(:fetch).and_call_original
-      allow(ENV).to receive(:fetch).with("MONGODB_HOST").and_return(SpecConfig.instance.addresses.first)
-      allow(ENV).to receive(:fetch).with("AWS_ACCESS_KEY_ID").and_return(ENV.fetch("MONGO_RUBY_DRIVER_AWS_AUTH_ACCESS_KEY_ID"))
-      allow(ENV).to receive(:fetch).with("AWS_SECRET_ACCESS_KEY").and_return(ENV.fetch("MONGO_RUBY_DRIVER_AWS_AUTH_SECRET_ACCESS_KEY"))
-      allow(ENV).to receive(:fetch).with("AWS_SESSION_TOKEN").and_return(ENV.fetch("MONGO_RUBY_DRIVER_AWS_AUTH_SESSION_TOKEN"))
-      allow(ENV).to receive(:fetch).with("MONGODB_DATABASE").and_return("test")
-
-      # Start AWS Lambda Example 2
-
-      # Require the driver library.
-      require "mongo"
-
-      # Create a Mongo::Client instance using AWS IAM authentication.
-      # CRITICAL: You must create the client instance outside the handler
-      # so that the client can be reused across function invocations.
-      client = Mongo::Client.new([ENV.fetch("MONGODB_HOST")],
-                                 auth_mech: :aws,
-                                 user: ENV.fetch("AWS_ACCESS_KEY_ID"),
-                                 password: ENV.fetch("AWS_SECRET_ACCESS_KEY"),
-                                 auth_mech_properties: {
-                                   aws_session_token: ENV.fetch("AWS_SESSION_TOKEN"),
-                                 },
-                                 database: ENV.fetch("MONGODB_DATABASE"))
-
-      def lambda_handler(event:, context:)
-        # Use the client to return the name of the configured database.
-        client.database.name
-      end
-
-      # End AWS Lambda Example 2
-
-      client.close
-    end
-  end
-
-end

data/spec/integration/bson_symbol_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'spec_helper'
-
-describe 'Symbol encoding to BSON' do
-  let(:value) { :foo }
-
-  let(:hash) do
-    {'foo' => value}
-  end
-
-  let(:serialized) do
-    hash.to_bson.to_s
-  end
-
-  let(:expected) do
-    (+"\x12\x00\x00\x00\x0Efoo\x00\x04\x00\x00\x00foo\x00\x00").force_encoding('binary')
-  end
-
-  it 'encodes symbol to BSON symbol' do
-    serialized.should == expected
-  end
-
-  it 'round-trips symbol values' do
-    buffer = BSON::ByteBuffer.new(serialized)
-    Hash.from_bson(buffer).should == hash
-  end
-
-  it 'round-trips symbol values using the same byte buffer' do
-    if BSON::Environment.jruby? && (BSON::VERSION.split('.').map(&:to_i) <=> [4, 11, 0]) < 0
-      skip 'This test is only relevant to bson versions that increment ByteBuffer '\
-       'read and write positions separately in JRuby, as implemented in ' \
-       'bson version 4.11.0. For more information, see https://jira.mongodb.org/browse/RUBY-2128'
-    end
-
-    Hash.from_bson(hash.to_bson).should == hash
-  end
-end

data/spec/integration/bulk_insert_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'spec_helper'
-
-describe 'Bulk insert' do
-  include PrimarySocket
-
-  let(:fail_point_base_command) do
-    { 'configureFailPoint' => "failCommand" }
-  end
-
-  let(:collection_name) { 'bulk_insert_spec' }
-  let(:collection) { authorized_client[collection_name] }
-
-  describe 'inserted_ids' do
-    before do
-      collection.delete_many
-    end
-
-    context 'success' do
-      it 'returns one insert_id as array' do
-        result = collection.insert_many([
-          {:_id => 9},
-        ])
-        expect(result.inserted_ids).to eql([9])
-      end
-    end
-
-    context 'error on first insert' do
-      it 'is an empty array' do
-        collection.insert_one(:_id => 9)
-        begin
-          result = collection.insert_many([
-            {:_id => 9},
-          ])
-          fail 'Should have raised'
-        rescue Mongo::Error::BulkWriteError => e
-          expect(e.result['inserted_ids']).to eql([])
-        end
-      end
-    end
-
-    context 'error on third insert' do
-      it 'is an array of the first two ids' do
-        collection.insert_one(:_id => 9)
-        begin
-          result = collection.insert_many([
-            {:_id => 7},
-            {:_id => 8},
-            {:_id => 9},
-          ])
-          fail 'Should have raised'
-        rescue Mongo::Error::BulkWriteError => e
-          expect(e.result['inserted_ids']).to eql([7, 8])
-        end
-      end
-    end
-
-    context 'entire operation fails' do
-      min_server_fcv '4.0'
-      require_topology :single, :replica_set
-
-      it 'is an empty array' do
-        collection.client.use(:admin).command(fail_point_base_command.merge(
-          :mode => {:times => 1},
-          :data => {:failCommands => ['insert'], errorCode: 100}))
-        begin
-          result = collection.insert_many([
-            {:_id => 7},
-            {:_id => 8},
-            {:_id => 9},
-          ])
-          fail 'Should have raised'
-        rescue Mongo::Error => e
-          result = e.send(:instance_variable_get, '@result')
-          expect(result).to be_a(Mongo::Operation::Insert::BulkResult)
-          expect(result.inserted_ids).to eql([])
-        end
-      end
-    end
-  end
-end

data/spec/integration/bulk_write_error_message_spec.rb

@@ -1,74 +0,0 @@
-# rubocop:todo all
-require 'spec_helper'
-
-describe 'BulkWriteError message' do
-  let(:client) { authorized_client }
-  let(:collection_name) { 'bulk_write_error_message_spec' }
-  let(:collection) { client[collection_name] }
-
-  before do
-    collection.delete_many
-  end
-
-  context 'a bulk write with one error' do
-    it 'reports code name, code and message' do
-      begin
-        collection.insert_many([
-          {_id: 1},
-          {_id: 1},
-          {_id: 1},
-        ], ordered: true)
-        fail('Should have raised')
-      rescue Mongo::Error::BulkWriteError => e
-        e.message.should =~ %r,\A\[11000\]: (insertDocument :: caused by :: 11000 )?E11000 duplicate key error (collection|index):,
-      end
-    end
-  end
-
-  context 'a bulk write with multiple errors' do
-    it 'reports code name, code and message' do
-      begin
-        collection.insert_many([
-          {_id: 1},
-          {_id: 1},
-          {_id: 1},
-        ], ordered: false)
-        fail('Should have raised')
-      rescue Mongo::Error::BulkWriteError => e
-        e.message.should =~ %r,\AMultiple errors: \[11000\]: (insertDocument :: caused by :: 11000 )?E11000 duplicate key error (collection|index):.*\[11000\]: (insertDocument :: caused by :: 11000 )?E11000 duplicate key error (collection|index):,
-      end
-    end
-  end
-
-  context 'a bulk write with validation errors' do
-
-    let(:collection_name) { 'bulk_write_error_validation_message_spec' }
-
-    let(:collection) do
-      client[:collection_name].drop
-      client[:collection_name,
-      {
-        'validator' => {
-          'x' => { '$type' => 'string' },
-        }
-      }].create
-      client[:collection_name]
-    end
-
-    it 'reports code name, code, message, and details' do
-      begin
-        collection.insert_one({_id:1, x:"1"})
-        collection.insert_many([
-          {_id: 1, x:"1"},
-          {_id: 2, x:1},
-        ], ordered: false)
-        fail('Should have raised')
-      rescue Mongo::Error::BulkWriteError => e
-        e.message.should =~ %r,\AMultiple errors: \[11000\]: (insertDocument :: caused by :: 11000 )?E11000 duplicate key error (collection|index):.*\; \[121\]: Document failed validation( -- .*)?,
-        # The duplicate key error should not print details because it's not a
-        # WriteError or a WriteConcernError
-        e.message.scan(/ -- /).length.should be <= 1
-      end
-    end
-  end
-end

data/spec/integration/bulk_write_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'spec_helper'
-
-describe 'Bulk writes' do
-  before do
-    authorized_collection.drop
-  end
-
-  context 'when bulk write is larger than 48MB' do
-    let(:operations) do
-      [ { insert_one: { text: 'a' * 1000 * 1000 } } ] * 48
-    end
-
-    it 'succeeds' do
-      expect do
-        authorized_collection.bulk_write(operations)
-      end.not_to raise_error
-    end
-
-    context 'in transaction' do
-      require_transaction_support
-      min_server_version "4.4"
-
-      it 'succeeds' do
-        authorized_collection.create
-        expect do
-          authorized_collection.client.start_session do |session|
-            session.with_transaction do
-              authorized_collection.bulk_write(operations, { session: session })
-            end
-          end
-        end.not_to raise_error
-      end
-    end
-  end
-
-  context 'when bulk write needs to be split' do
-    let(:subscriber) { Mrss::EventSubscriber.new }
-
-    let(:max_bson_size) { Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE }
-
-    let(:insert_events) do
-      subscriber.command_started_events('insert')
-    end
-
-    let(:failed_events) do
-      subscriber.failed_events
-    end
-
-    let(:operations) do
-      [{ insert_one: { text: 'a' * (max_bson_size/2) } }] * 6
-    end
-
-    before do
-      authorized_client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-      authorized_collection.bulk_write(operations)
-    end
-
-    context '3.6+ server' do
-      min_server_fcv '3.6'
-
-      it 'splits the operations' do
-        # 3.6+ servers can send multiple bulk operations in one message,
-        # with the whole message being limited to 48m.
-        expect(insert_events.length).to eq(2)
-      end
-    end
-
-    context 'pre-3.6 server' do
-      max_server_version '3.4'
-
-      it 'splits the operations' do
-        # Pre-3.6 servers limit the entire message payload to the size of
-        # a single document which is 16m. Given our test data this means
-        # twice as many messages are sent.
-        expect(insert_events.length).to eq(4)
-      end
-    end
-
-    it 'does not have a command failed event' do
-      expect(failed_events).to be_empty
-    end
-  end
-end