mongo 2.10.5 → 2.11.0.rc0

data/lib/mongo/event/description_changed.rb

@@ -1,52 +0,0 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Mongo
-  module Event
-
-    # This handles a change in description.
-    #
-    # @since 2.0.6
-    class DescriptionChanged < Base
-
-      # @return [ Mongo::Cluster ] cluster The cluster.
-      attr_reader :cluster
-
-      # Initialize the new host added event handler.
-      #
-      # @example Create the new handler.
-      #   ServerAdded.new(cluster)
-      #
-      # @param [ Mongo::Cluster ] cluster The cluster to publish from.
-      #
-      # @since 2.0.0
-      def initialize(cluster)
-        @cluster = cluster
-      end
-
-      # This event publishes an event to add the cluster and logs the
-      # configuration change.
-      #
-      # @param [ Server::Description ] previous_desc Previous server description.
-      # @param [ Server::Description ] updated_desc The changed description.
-      #
-      # @since 2.0.0
-      def handle(previous_desc, updated_desc)
-        cluster.sdam_flow_lock.synchronize do
-          Mongo::Cluster::SdamFlow.new(cluster, previous_desc, updated_desc).server_description_changed
-        end
-      end
-    end
-  end
-end

data/spec/integration/bson_symbol_spec.rb

@@ -1,34 +0,0 @@
-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?
-      pending 'https://jira.mongodb.org/browse/RUBY-2128'
-    end
-
-    Hash.from_bson(hash.to_bson).should == hash
-  end
-end

data/spec/integration/crud_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe 'CRUD operations' do
-  let(:collection) { authorized_client['crud_integration'] }
-
-  before do
-    collection.delete_many
-  end
-
-  describe 'upsert' do
-    context 'with default write concern' do
-      it 'upserts' do
-        collection.count_documents({}).should == 0
-
-        res = collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
-
-        res.documents.first['upserted'].length.should == 1
-
-        collection.count_documents({}).should == 1
-      end
-    end
-
-    context 'unacknowledged write' do
-      let(:unack_collection) do
-        collection.with(write_concern: {w: 0})
-      end
-
-      before do
-        unack_collection.write_concern.acknowledged?.should be false
-      end
-
-      it 'upserts' do
-        unack_collection.count_documents({}).should == 0
-
-        res = unack_collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
-
-        # since write concern is unacknowledged, wait for the data to be
-        # persisted (hopefully)
-        sleep 0.25
-
-        unack_collection.count_documents({}).should == 1
-      end
-    end
-  end
-end

data/spec/integration/get_more_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe 'getMore operation' do
-  # https://jira.mongodb.org/browse/RUBY-1987
-  min_server_fcv '3.2'
-
-  let(:collection) do
-    subscribed_client['get_more_spec']
-  end
-
-  let(:scope) do
-    collection.find.batch_size(1).each
-  end
-
-  before do
-    collection.delete_many
-    collection.insert_one(a: 1)
-    #collection.insert_one(a: 2)
-    EventSubscriber.clear_events!
-  end
-
-  let(:get_more_command) do
-    event = EventSubscriber.single_command_started_event('getMore')
-    event.command['getMore']
-  end
-
-  it 'sends cursor id as int64' do
-    scope.to_a
-
-    expect(get_more_command).to be_a(BSON::Int64)
-  end
-end

data/spec/integration/grid_fs_bucket_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe 'GridFS bucket integration' do
-  let(:fs) do
-    authorized_client.database.fs
-  end
-
-  describe 'UTF-8 string write' do
-    let(:data) { "hello\u2210" }
-
-    before do
-      data.length.should_not == data.bytesize
-    end
-
-    shared_examples 'round-trips' do
-      it 'round-trips' do
-        stream = fs.open_upload_stream('test') do |stream|
-          stream.write(data_to_write)
-        end
-
-        actual = nil
-        fs.open_download_stream(stream.file_id) do |stream|
-          actual = stream.read
-        end
-
-        actual.encoding.name.should == 'ASCII-8BIT'
-        actual.should == data.dup.force_encoding('binary')
-      end
-    end
-
-    context 'in binary encoding' do
-      let(:data_to_write) do
-        data.force_encoding('binary').freeze
-      end
-
-      it_behaves_like 'round-trips'
-    end
-
-    context 'in UTF-8 encoding' do
-      let(:data_to_write) do
-        data.encoding.name.should == 'UTF-8'
-        data.freeze
-      end
-
-      it_behaves_like 'round-trips'
-    end
-  end
-end

data/spec/integration/retryable_errors_spec.rb

@@ -1,265 +0,0 @@
-require 'spec_helper'
-
-describe 'Failing retryable operations' do
-  # Requirement for fail point
-  min_server_fcv '4.0'
-
-  let(:client) do
-    subscribed_client
-  end
-
-  let(:collection) do
-    client['retryable-errors-spec']
-  end
-
-  context 'when operation fails' do
-    require_topology :replica_set
-
-
-    let(:clear_fail_point_command) do
-      {
-        configureFailPoint: 'failCommand',
-        mode: 'off',
-      }
-    end
-
-    after do
-      ClusterTools.instance.direct_client_for_each_server do |client|
-        client.use(:admin).database.command(clear_fail_point_command)
-      end
-    end
-
-    let(:collection) do
-      client['retryable-errors-spec', read: {mode: :secondary_preferred}]
-    end
-
-    let(:first_server) do
-      client.cluster.servers_list.detect do |server|
-        server.address.seed == events.first.address.seed
-      end
-    end
-
-    let(:second_server) do
-      client.cluster.servers_list.detect do |server|
-        server.address.seed == events.last.address.seed
-      end
-    end
-
-    shared_context 'read operation' do
-      let(:fail_point_command) do
-        {
-          configureFailPoint: 'failCommand',
-          mode: {times: 1},
-          data: {
-            failCommands: ['find'],
-            errorCode: 11600,
-          },
-        }
-      end
-
-      let(:set_fail_point) do
-        client.cluster.servers_list.each do |server|
-          server.scan!
-          server.monitor.stop!
-        end
-
-        ClusterTools.instance.direct_client_for_each_server do |client|
-          client.use(:admin).database.command(fail_point_command)
-        end
-      end
-
-      let(:operation_exception) do
-        set_fail_point
-
-        begin
-          collection.find(a: 1).to_a
-        rescue Mongo::Error::OperationFailure => exception
-        else
-          fail('Expected operation to fail')
-        end
-
-        puts exception.message
-
-        exception
-      end
-
-      let(:events) do
-        EventSubscriber.command_started_events('find')
-      end
-    end
-
-    shared_context 'write operation' do
-      let(:fail_point_command) do
-        {
-          configureFailPoint: 'failCommand',
-          mode: {times: 2},
-          data: {
-            failCommands: ['insert'],
-            errorCode: 11600,
-          },
-        }
-      end
-
-      let(:set_fail_point) do
-        client.use(:admin).database.command(fail_point_command)
-      end
-
-      let(:operation_exception) do
-        set_fail_point
-
-        begin
-          collection.insert_one(a: 1)
-        rescue Mongo::Error::OperationFailure => exception
-        else
-          fail('Expected operation to fail')
-        end
-
-        #puts exception.message
-
-        exception
-      end
-
-      let(:events) do
-        EventSubscriber.command_started_events('insert')
-      end
-    end
-
-    shared_examples_for 'failing retry' do
-
-      it 'indicates second attempt' do
-        expect(operation_exception.message).to include('attempt 2')
-        expect(operation_exception.message).not_to include('attempt 1')
-        expect(operation_exception.message).not_to include('attempt 3')
-      end
-
-      it 'publishes two events' do
-
-        expect(events.length).to eq(2)
-      end
-    end
-
-    shared_examples_for 'failing single attempt' do
-
-      it 'does not indicate attempt' do
-        expect(operation_exception.message).not_to include('attempt 1')
-        expect(operation_exception.message).not_to include('attempt 2')
-        expect(operation_exception.message).not_to include('attempt 3')
-      end
-
-      it 'publishes one event' do
-
-        expect(events.length).to eq(1)
-      end
-    end
-
-    shared_examples_for 'failing retry on the same server' do
-      it 'is reported on the server of the second attempt' do
-        expect(operation_exception.message).to include(second_server.address.seed)
-      end
-    end
-
-    shared_examples_for 'failing retry on a different server' do
-      it 'is reported on the server of the second attempt' do
-        expect(operation_exception.message).not_to include(first_server.address.seed)
-        expect(operation_exception.message).to include(second_server.address.seed)
-      end
-
-      it 'marks servers used in both attempts unknown' do
-        operation_exception
-
-        expect(first_server).to be_unknown
-
-        expect(second_server).to be_unknown
-      end
-
-      it 'publishes events for the different server addresses' do
-
-        expect(events.length).to eq(2)
-        expect(events.first.address.seed).not_to eq(events.last.address.seed)
-      end
-    end
-
-    shared_examples_for 'modern retry' do
-      it 'indicates modern retry' do
-        expect(operation_exception.message).to include('modern retry')
-        expect(operation_exception.message).not_to include('legacy retry')
-        expect(operation_exception.message).not_to include('retries disabled')
-      end
-    end
-
-    shared_examples_for 'legacy retry' do
-      it 'indicates legacy retry' do
-        expect(operation_exception.message).to include('legacy retry')
-        expect(operation_exception.message).not_to include('modern retry')
-        expect(operation_exception.message).not_to include('retries disabled')
-      end
-    end
-
-    shared_examples_for 'disabled retry' do
-      it 'indicates retries are disabled' do
-        expect(operation_exception.message).to include('retries disabled')
-        expect(operation_exception.message).not_to include('legacy retry')
-        expect(operation_exception.message).not_to include('modern retry')
-      end
-    end
-
-    context 'when read is retried and retry fails' do
-      include_context 'read operation'
-
-      context 'modern read retries' do
-        require_wired_tiger_on_36
-
-        let(:client) do
-          subscribed_client.with(retry_reads: true)
-        end
-
-        it_behaves_like 'failing retry'
-        it_behaves_like 'modern retry'
-      end
-
-      context 'legacy read retries' do
-        let(:client) do
-          subscribed_client.with(retry_reads: false, read_retry_interval: 0)
-        end
-
-        it_behaves_like 'failing retry'
-        it_behaves_like 'legacy retry'
-      end
-    end
-
-    context 'when read retries are disabled' do
-      let(:client) do
-        subscribed_client.with(retry_reads: false, max_read_retries: 0)
-      end
-
-      include_context 'read operation'
-
-      it_behaves_like 'failing single attempt'
-      it_behaves_like 'disabled retry'
-    end
-
-    context 'when write is retried and retry fails' do
-      include_context 'write operation'
-
-      context 'modern write retries' do
-        require_wired_tiger_on_36
-
-        let(:client) do
-          subscribed_client.with(retry_writes: true)
-        end
-
-        it_behaves_like 'failing retry'
-        it_behaves_like 'modern retry'
-      end
-
-      context 'legacy write' do
-        let(:client) do
-          subscribed_client.with(retry_writes: false)
-        end
-
-        it_behaves_like 'failing retry'
-        it_behaves_like 'legacy retry'
-      end
-    end
-  end
-end