mongo 2.10.5 → 2.11.0.rc0

data/spec/integration/size_limit_spec.rb~12e1e9c4f... RUBY-2242 Fix zlib compression (#2021)

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe 'BSON & command size limits' do
-  let(:max_document_size) { 16*1024*1024 }
-
-  before do
-    authorized_collection.delete_many
-  end
-
-  # This test uses a large document that is significantly smaller than the
-  # size limit. It is a basic sanity check.
-  it 'allows user-provided documents to be 15MiB' do
-    document = { key: 'a' * 15*1024*1024, _id: 'foo' }
-
-    authorized_collection.insert_one(document)
-  end
-
-  # This test uses a large document that is significantly larger than the
-  # size limit. It is a basic sanity check.
-  it 'fails single write of oversized documents' do
-    document = { key: 'a' * 17*1024*1024, _id: 'foo' }
-
-    lambda do
-      authorized_collection.insert_one(document)
-    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
-  end
-
-  # This test checks our bulk write splitting when documents are not close
-  # to the limit, but where splitting is definitely required.
-  it 'allows split bulk write of medium sized documents' do
-    # 8 documents of 4 MiB each = 32 MiB total data, should be split over
-    # either 2 or 3 bulk writes depending on how well the driver splits
-    documents = []
-    1.upto(8) do |index|
-      documents << { key: 'a' * 4*1024*1024, _id: "in#{index}" }
-    end
-
-    authorized_collection.insert_many(documents)
-    authorized_collection.count_documents({}).should == 8
-  end
-
-  # This test ensures that document which are too big definitely fail insertion.
-  it 'fails bulk write of oversized documents' do
-    documents = []
-    1.upto(3) do |index|
-      documents << { key: 'a' * 17*1024*1024, _id: "in#{index}" }
-    end
-
-    lambda do
-      authorized_collection.insert_many(documents)
-    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
-    authorized_collection.count_documents({}).should == 0
-  end
-
-  it 'allows user-provided documents to be exactly 16MiB' do
-    # The document must contain the _id field, otherwise the server will
-    # add it which will increase the size of the document as persisted by
-    # the server.
-    document = { key: 'a' * (max_document_size - 28), _id: 'foo' }
-    expect(document.to_bson.length).to eq(max_document_size)
-
-    authorized_collection.insert_one(document)
-  end
-
-  it 'fails on the server when a document larger than 16MiB is inserted' do
-    document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
-    expect(document.to_bson.length).to eq(max_document_size+1)
-
-    lambda do
-      authorized_collection.insert_one(document)
-    end.should raise_error(Mongo::Error::OperationFailure, /object to insert too large/)
-  end
-
-  it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do
-    document = { key: 'a' * (max_document_size - 27 + 16*1024), _id: 'foo' }
-    expect(document.to_bson.length).to eq(max_document_size+16*1024+1)
-
-    lambda do
-      authorized_collection.insert_one(document)
-    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
-  end
-
-  it 'allows bulk writes of multiple documents of exactly 16 MiB each' do
-    if SpecConfig.instance.compressors
-      pending "RUBY-2234"
-    end
-
-    documents = []
-    1.upto(3) do |index|
-      document = { key: 'a' * (max_document_size - 28), _id: "in#{index}" }
-      expect(document.to_bson.length).to eq(max_document_size)
-      documents << document
-    end
-
-    authorized_collection.insert_many(documents)
-    authorized_collection.count_documents({}).should == 3
-  end
-end

data/spec/mongo/cursor/builder/op_kill_cursors_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Cursor::Builder::OpKillCursors do
-
-  let(:reply) do
-    Mongo::Protocol::Reply.allocate.tap do |reply|
-      allow(reply).to receive(:cursor_id).and_return(8000)
-    end
-  end
-
-  let(:result) do
-    Mongo::Operation::Result.new(reply)
-  end
-
-  let(:view) do
-    Mongo::Collection::View.new(
-      authorized_collection,
-      {},
-      tailable: true,
-      max_time_ms: 100
-    )
-  end
-
-  let(:cursor) do
-    Mongo::Cursor.new(view, result, authorized_primary)
-  end
-
-  let(:builder) do
-    described_class.new(cursor)
-  end
-
-  describe '#specification' do
-
-    let(:specification) do
-      builder.specification
-    end
-
-    it 'includes the cursor ids' do
-      expect(specification[:cursor_ids]).to eq([BSON::Int64.new(8000)])
-    end
-
-    it 'includes the database name' do
-      expect(specification[:db_name]).to eq(SpecConfig.instance.test_db)
-    end
-
-    it 'includes the collection name' do
-      expect(specification[:coll_name]).to eq(TEST_COLL)
-    end
-  end
-
-  describe '.get_cursors_list' do
-    it 'returns integer cursor ids' do
-      expect(described_class.get_cursors_list(builder.specification)).to eq([8000])
-    end
-  end
-end

data/spec/runners/sdam/verifier.rb

@@ -1,88 +0,0 @@
-module Sdam
-  class Verifier
-    include RSpec::Matchers
-
-    def verify_sdam_event(expected_events, actual_events, i)
-      expect(expected_events.length).to be > i
-      expect(actual_events.length).to be > i
-
-      expected_event = expected_events[i]
-      actual_event = actual_events[i]
-
-      actual_event_name = Utils.underscore(actual_event.class.name.sub(/.*::/, ''))
-      actual_event_name = actual_event_name.to_s.sub('topology_changed', 'topology_description_changed') + '_event'
-      expect(actual_event_name).to eq(expected_event.name)
-
-      send("verify_#{expected_event.name}", expected_event, actual_event)
-    end
-
-    def verify_topology_opening_event(expected, actual)
-      expect(actual.topology).not_to be nil
-    end
-
-    def verify_topology_description_changed_event(expected, actual)
-      verify_topology_matches(expected.data['previousDescription'], actual.previous_topology)
-      verify_topology_matches(expected.data['newDescription'], actual.new_topology)
-    end
-
-    def verify_topology_matches(expected, actual)
-      expected_type = ::Mongo::Cluster::Topology.const_get(expected['topologyType'])
-      expect(actual).to be_a(expected_type)
-
-      expect(actual.replica_set_name).to eq(expected['setName'])
-
-      expected['servers'].each do |server|
-        desc = actual.server_descriptions[server['address'].to_s]
-        expect(desc).not_to be nil
-        verify_description_matches(server, desc)
-      end
-
-      actual.server_descriptions.keys.each do |address_str|
-        expect(
-          expected['servers'].any? { |server| server['address'] == address_str }
-        ).to be true
-      end
-    end
-
-    def verify_server_opening_event(expected, actual)
-      expect(actual.address.to_s).to eq(expected.data['address'])
-    end
-
-    def verify_server_description_changed_event(expected, actual)
-      verify_description_matches(expected.data['previousDescription'], actual.previous_description)
-      verify_description_matches(expected.data['newDescription'], actual.new_description)
-    end
-
-    def verify_description_matches(expected, actual)
-      case expected['type']
-      when 'Standalone'
-        expect(actual).to be_standalone
-      when 'RSPrimary'
-        expect(actual).to be_primary
-      when 'RSSecondary'
-        expect(actual).to be_secondary
-      when 'RSArbiter'
-        expect(actual).to be_arbiter
-      when 'Mongos'
-        expect(actual).to be_mongos
-      when 'Unknown', 'PossiblePrimary'
-        expect(actual).to be_unknown
-      when 'RSGhost'
-        expect(actual).to be_ghost
-      when 'RSOther'
-        expect(actual).to be_other
-      end
-
-      expect(actual.address.to_s).to eq(expected['address'])
-      expect(actual.arbiters).to eq(expected['arbiters'])
-      expect(actual.hosts).to eq(expected['hosts'])
-      expect(actual.passives).to eq(expected['passives'])
-      expect(actual.primary_host).to eq(expected['primary'])
-      expect(actual.replica_set_name).to eq(expected['setName'])
-    end
-
-    def verify_server_closed_event(expected, actual)
-      expect(actual.address.to_s).to eq(expected.data['address'])
-    end
-  end
-end