mongo 2.0.6 → 2.1.0

data/lib/mongo/operation/write/bulk/legacy_bulk_mergable.rb

@@ -1,83 +0,0 @@
-# Copyright (C) 2014-2015 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 Operation
-    module Write
-
-      module LegacyBulkMergable
-
-        # Aggregate the write errors returned from this result.
-        #
-        # @example Aggregate the write errors.
-        #   result.aggregate_write_errors([0, 1, 2, 3])
-        #
-        # @param [ Array ] indexes The indexes of each operation as they
-        #   were listed in the Bulk API.
-        #
-        # @return [ Array ] The aggregate write errors.
-        #
-        # @since 2.0.0
-        def aggregate_write_errors(indexes)
-          @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
-            if reply_write_errors?(reply)
-              errors ||= []
-              errors << { 'errmsg' => reply.documents.first[Error::ERROR],
-                          'index' => indexes[i],
-                          'code' => reply.documents.first[Error::CODE] }
-            end
-            errors
-          end
-        end
-
-        # Aggregate the write concern errors returned from this result.
-        #
-        # @example Aggregate the write concern errors.
-        #   result.aggregate_write_concern_errors([0, 1, 2, 3])
-        #
-        # @param [ Array ] indexes The indexes of each operation as they
-        #   were listed in the Bulk API.
-        #
-        # @return [ Array ] The aggregate write concern errors.
-        #
-        # @since 2.0.0
-        def aggregate_write_concern_errors(indexes)
-          @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
-            if error = reply_write_errors?(reply)
-              errors ||= []
-              if note = reply.documents.first['wnote'] || reply.documents.first['jnote']
-                code = reply.documents.first['code'] || Error::BAD_VALUE
-                error_string = "#{code}: #{note}"
-              elsif error == 'timeout'
-                code = reply.documents.first['code'] || Error::UNKNOWN_ERROR
-                error_string = "#{code}: #{error}"
-              end
-              errors << { 'errmsg' => error_string,
-                          'index' => indexes[i],
-                          'code' => code } if error_string
-            end
-            errors
-          end
-        end
-
-        private
-
-        def reply_write_errors?(reply)
-          reply.documents.first[Error::ERROR] ||
-            reply.documents.first[Error::ERRMSG]
-        end
-      end
-    end
-  end
-end

data/spec/mongo/bulk/bulk_write_spec.rb

@@ -1,262 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::BulkWrite do
-
-  before do
-    authorized_collection.find.delete_many
-  end
-
-  after do
-    authorized_collection.find.delete_many
-  end
-
-  let(:bulk) do
-    described_class.get(authorized_collection, operations, options)
-  end
-
-  describe '#get' do
-
-    let(:operations) do
-      [{ insert_one: { _id: 0 } }]
-    end
-
-    context 'When an ordered bulk write object is created' do
-
-      let(:options) do
-        { ordered: true }
-      end
-
-      it 'returns an OrderedBulkWrite object' do
-        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
-      end
-    end
-
-    context 'When an unordered bulk write object is created' do
-
-      let(:options) do
-        { ordered: false }
-      end
-
-      it 'returns an UnorderedBulkWrite object' do
-        expect(bulk).to be_a(Mongo::BulkWrite::UnorderedBulkWrite)
-      end
-    end
-
-    context 'When ordered is not specified in options' do
-
-      let(:options) do
-        { }
-      end
-
-      it 'returns an OrderedBulkWrite object' do
-        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
-      end
-    end
-  end
-
-  describe 'Ordered bulk write' do
-
-    let(:options) do
-       { ordered: true }
-    end
-     
-    it_behaves_like 'a bulk write object'
-    
-    context 'when the batch requires splitting' do
-    
-      context 'when the operations are the same type' do
-    
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
-        end
-    
-        let(:operations) do
-          [].tap do |ops|
-            3000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 3001 } }
-          end
-        end
-    
-        it 'raises a BulkWriteError' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
-        end
-
-        it 'halts execution after first error and reports correct index' do
-          expect(error.result[:write_errors].first['index']).to eq(3000)
-          expect(authorized_collection.find.count).to eq(3000)
-        end
-      end
-
-      context 'when operations are mixed types' do
-
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
-        end
-
-        let(:operations) do
-          [].tap do |ops|
-            2000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { delete_one: { _id: 0 } }
-            ops << { insert_one: { _id: 1 } }
-            ops << { insert_one: { _id: 2000 } }
-          end
-        end
-
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
-        end
-
-        it 'halts execution after first error and reports correct index' do
-          expect(error.result[:write_errors].first['index']).to eq(2001)
-          expect(authorized_collection.find.count).to eq(1999)
-        end
-      end
-
-      context 'when the operations exceed the max bson size' do
-
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
-        end
-    
-        let(:operations) do
-          [].tap do |ops|
-            6.times do |i|
-              ops << { insert_one: { _id: i, x: 'y'*4000000 } }
-            end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 100 } }
-          end
-        end
-    
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
-        end
-    
-        it 'splits messages into multiple messages' do
-          error
-          expect(authorized_collection.find.count).to eq(6)
-        end
-      end
-    end
-  end
-
-  describe 'Unordered bulk write' do
-
-    let(:options) do
-       { ordered: false }
-    end
-
-    it_behaves_like 'a bulk write object'
-
-    context 'when the operations exceed the max batch size' do
-
-      context 'when operations are all the same type' do
-
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
-        end
-
-        let(:operations) do
-          [].tap do |ops|
-            3000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 3001 } }
-          end
-        end
-
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
-        end
-
-        it 'does not halt execution after first error' do
-          expect(error.result[:write_errors].first['index']).to eq(3000)
-          expect(authorized_collection.find.count).to eq(3001)
-        end
-      end
-
-      context 'when operations are mixed types' do
-
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
-        end
-
-        let(:operations) do
-          [].tap do |ops|
-            2000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { delete_one: { _id: 0 } }
-            ops << { insert_one: { _id: 1 } }
-            ops << { insert_one: { _id: 2000 } }
-          end
-        end
-
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
-        end
-
-        it 'does not halt execution after first error' do
-          expect(error.result[:write_errors].first['index']).to eq(2001)
-          expect(authorized_collection.find.count).to eq(2000)
-        end
-      end
-
-      context 'when the operations exceed the max bson size' do
-
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
-        end
-
-        let(:operations) do
-          [].tap do |ops|
-            15.times do |i|
-              ops << { insert_one: { _id: i, x: 'y'*4000000 } }
-            end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 100 } }
-          end
-        end
-
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
-        end
-
-        it 'splits messages into multiple messages' do
-          error
-          expect(authorized_collection.find.count).to eq(16)
-        end
-      end
-    end
-  end
-end

data/spec/mongo/grid/fs_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Grid::FS do
-
-  describe '#initialize' do
-
-    let(:fs) do
-      described_class.new(authorized_client.database)
-    end
-
-    let(:index) do
-      fs.chunks_collection.indexes.get(:files_id => 1, :n => 1)
-    end
-
-    it 'sets the files collection' do
-      expect(fs.files_collection.name).to eq('fs.files')
-    end
-
-    it 'sets the chunks collection' do
-      expect(fs.chunks_collection.name).to eq('fs.chunks')
-    end
-
-    it 'creates the index on the chunks collection' do
-      expect(index[:name]).to eq('files_id_1_n_1')
-    end
-  end
-
-  describe '#find_one' do
-
-    let(:fs) do
-      described_class.new(authorized_client.database)
-    end
-
-    let(:file) do
-      Mongo::Grid::File.new('hello world!', :filename => 'test.txt')
-    end
-
-    before do
-      fs.insert_one(file)
-    end
-
-    after do
-      fs.files_collection.find.delete_many
-      fs.chunks_collection.find.delete_many
-    end
-
-    let(:from_db) do
-      fs.find_one(:filename => 'test.txt')
-    end
-
-    it 'returns the assembled file from the db' do
-      expect(from_db.filename).to eq(file.metadata.filename)
-    end
-  end
-
-  describe '#insert_one' do
-
-    let(:fs) do
-      described_class.new(authorized_client.database)
-    end
-
-    let(:file) do
-      Mongo::Grid::File.new('Hello!', :filename => 'test.txt')
-    end
-
-    context 'when inserting the file once' do
-
-      let!(:result) do
-        fs.insert_one(file)
-      end
-
-      after do
-        fs.files_collection.find.delete_many
-        fs.chunks_collection.find.delete_many
-      end
-
-      let(:from_db) do
-        fs.find_one(:filename => 'test.txt')
-      end
-
-      it 'inserts the file into the database' do
-        expect(from_db.filename).to eq(file.metadata.filename)
-      end
-
-      it 'includes the chunks and data with the file' do
-        expect(from_db.data).to eq('Hello!')
-      end
-
-      it 'returns the file id' do
-        expect(result).to eq(file.id)
-      end
-    end
-
-    context 'when inserting the file more than once' do
-
-      after do
-        fs.files_collection.find.delete_many
-        fs.chunks_collection.find.delete_many
-      end
-
-      it 'raises an error' do
-        expect {
-          fs.insert_one(file)
-          fs.insert_one(file)
-        }.to raise_error(Mongo::Error::OperationFailure)
-      end
-    end
-
-    context 'when the file exceeds the max bson size' do
-
-      let(:fs) do
-        described_class.new(authorized_client.database)
-      end
-
-      let(:file) do
-        str = 'y' * 16777216
-        Mongo::Grid::File.new(str, :filename => 'large-file.txt')
-      end
-
-      before do
-        fs.insert_one(file)
-      end
-
-      after do
-        fs.files_collection.find.delete_many
-        fs.chunks_collection.find.delete_many
-      end
-
-      it 'successfully inserts the file' do
-        expect(
-          fs.find_one(:filename => 'large-file.txt').chunks
-        ).to eq(file.chunks)
-      end
-    end
-  end
-
-  describe '#delete_one' do
-
-    let(:fs) do
-      described_class.new(authorized_client.database)
-    end
-
-    let(:file) do
-      Mongo::Grid::File.new('Hello!', :filename => 'test.txt')
-    end
-
-    before do
-      fs.insert_one(file)
-      fs.delete_one(file)
-    end
-
-    let(:from_db) do
-      fs.find_one(:filename => 'test.txt')
-    end
-
-    it 'removes the file from the db' do
-      expect(from_db).to be_nil
-    end
-  end
-end

data/spec/mongo/loggable_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Loggable do
-
-  let(:operation) do
-    Class.new do
-      def log_message
-        'test'
-      end
-    end.new
-  end
-
-  describe '#log' do
-
-    let(:loggable) do
-      Class.new do
-        include Mongo::Loggable
-      end.new
-    end
-
-    let(:operation) do
-      double('operation')
-    end
-
-    before do
-      Mongo::Logger.level = Logger::DEBUG
-      expect(operation).to receive(:log_message).and_return('test')
-      expect(Mongo::Logger).to receive(:log).with(:debug, 'MONGO', 'test', anything())
-    end
-
-    context 'when a block is provided' do
-
-      context 'when an exception occurs' do
-
-        it 'logs the message' do
-          expect {
-            loggable.log(:debug, 'MONGO', [ operation ]) do
-              raise RuntimeError
-            end
-          }.to raise_error(RuntimeError)
-        end
-      end
-
-      context 'when no exception occurs' do
-
-        it 'executes the block and logs the message' do
-          expect(
-            loggable.log(:debug, 'MONGO', [ operation ]) do
-              'testing'
-            end
-          ).to eq('testing')
-        end
-      end
-    end
-
-    context 'when no block is provided' do
-
-      it 'logs the message' do
-        expect(loggable.log(:debug, 'MONGO', [ operation ])).to be_nil
-      end
-    end
-  end
-end

data/spec/mongo/operation/aggregate_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Operation::Aggregate do
-  include_context 'operation'
-
-  let(:selector) do
-    { :aggregate => coll_name,
-      :pipeline => [],
-    }
-  end
-  let(:spec) do
-    { :selector => selector,
-      :options => {},
-      :db_name => db_name
-    }
-  end
-  let(:op) { described_class.new(spec) }
-
-
-  describe '#initialize' do
-
-    context 'spec' do
-
-      it 'sets the spec' do
-        expect(op.spec).to be(spec)
-      end
-    end
-  end
-
-  describe '#==' do
-
-    context ' when two ops have different specs' do
-      let(:other_selector) do
-        { :aggregate => 'another_test_coll',
-          :pipeline => [],
-        }
-      end
-      let(:other_spec) do
-        { :selector => other_selector,
-          :options => options,
-          :db_name => db_name,
-        }
-      end
-      let(:other) { described_class.new(other_spec) }
-
-      it 'returns false' do
-        expect(op).not_to eq(other)
-      end
-    end
-  end
-
-  context '#merge' do
-    let(:other_op) { described_class.new(spec) }
-
-    it 'is not allowed' do
-      expect{ op.merge(other_op) }.to raise_exception
-    end
-  end
-
-  context '#merge!' do
-    let(:other_op) { described_class.new(spec) }
-
-    it 'is not allowed' do
-      expect{ op.merge!(other_op) }.to raise_exception
-    end
-  end
-
-  describe '#execute' do
-
-    context 'when the aggregation fails' do
-
-      let(:selector) do
-        { :aggregate => coll_name,
-          :pipeline => [{ '$invalid' => 'operator' }],
-        }
-      end
-
-      it 'raises an exception' do
-        expect {
-          op.execute(authorized_primary.context)
-        }.to raise_error(Mongo::Error::OperationFailure)
-      end
-    end
-
-    context 'rerouting' do
-
-      before do
-        allow_any_instance_of(Mongo::Operation::Aggregate::Result).to receive(:validate!) do
-          true
-        end
-      end
-
-      context 'when out is specified and server is a secondary' do
-        let(:selector) do
-          { :aggregate => 'test_coll',
-            :pipeline => [{ '$out' => 'test_coll' }],
-          }
-        end
-
-        it 'raises an error' do
-          allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
-            primary_server
-          end
-          expect {
-            op.execute(secondary_context)
-          }.to raise_error(Mongo::Error::NeedPrimaryServer)
-        end
-      end
-
-      context 'when out is specified and server is a primary' do
-        let(:selector) do
-          { :aggregate => 'test_coll',
-            :pipeline => [{ '$out' => 'test_coll' }],
-          }
-        end
-
-        it 'sends the operation to the primary' do
-          allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
-            primary_server
-          end
-          expect(primary_context).to receive(:with_connection)
-          op.execute(primary_context)
-        end
-      end
-    end
-  end
-end