mongo 1.12.5 → 2.0.0

data/spec/mongo/index/view_spec.rb

@@ -0,0 +1,330 @@
+require 'spec_helper'
+
+describe Mongo::Index::View do
+
+  let(:view) do
+    described_class.new(authorized_collection)
+  end
+
+  describe '#drop_one' do
+
+    let(:spec) do
+      { another: -1 }
+    end
+
+    before do
+      view.create_one(spec, unique: true)
+    end
+
+    context 'when the index exists' do
+
+      let(:result) do
+        view.drop_one('another_-1')
+      end
+
+      it 'drops the index' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'when passing a * as the name' do
+
+      it 'raises an exception' do
+        expect {
+          view.drop_one('*')
+        }.to raise_error(Mongo::Error::MultiIndexDrop)
+      end
+    end
+  end
+
+  describe '#drop_all' do
+
+    let(:spec) do
+      { another: -1 }
+    end
+
+    before do
+      view.create_one(spec, unique: true)
+    end
+
+    context 'when indexes exists' do
+
+      let(:result) do
+        view.drop_all
+      end
+
+      it 'drops the index' do
+        expect(result).to be_successful
+      end
+    end
+  end
+
+  describe '#create_many' do
+
+    context 'when the indexes are created' do
+
+      context 'when passing multi-args' do
+
+        let(:result) do
+          view.create_many(
+            { key: { random: 1 }, unique: true },
+            { key: { testing: -1 }, unique: true }
+          )
+        end
+
+        after do
+          view.drop_one('random_1')
+          view.drop_one('testing_-1')
+        end
+
+        it 'returns ok' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'when passing an array' do
+
+        let(:result) do
+          view.create_many([
+            { key: { random: 1 }, unique: true },
+            { key: { testing: -1 }, unique: true }
+          ])
+        end
+
+        after do
+          view.drop_one('random_1')
+          view.drop_one('testing_-1')
+        end
+
+        it 'returns ok' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'when index creation fails' do
+
+        let(:spec) do
+          { name: 1 }
+        end
+
+        before do
+          view.create_one(spec, unique: true)
+        end
+
+        after do
+          view.drop_one('name_1')
+        end
+
+        it 'raises an exception', if: write_command_enabled? do
+          expect {
+            view.create_many([{ key: { name: 1 }, unique: false }])
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+
+        it 'does not raise an exception', unless: write_command_enabled? do
+          expect(view.create_many([{ key: { name: 1 }, unique: false }])).to be_successful
+        end
+      end
+    end
+  end
+
+  describe '#create_one' do
+
+    context 'when the index is created' do
+
+      let(:spec) do
+        { random: 1 }
+      end
+
+      let(:result) do
+        view.create_one(spec, unique: true)
+      end
+
+      after do
+        view.drop_one('random_1')
+      end
+
+      it 'returns ok' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'when index creation fails' do
+
+      let(:spec) do
+        { name: 1 }
+      end
+
+      before do
+        view.create_one(spec, unique: true)
+      end
+
+      after do
+        view.drop_one('name_1')
+      end
+
+      it 'raises an exception', if: write_command_enabled? do
+        expect {
+          view.create_one(spec, unique: false)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+
+      it 'does not raise an exception', unless: write_command_enabled? do
+        expect(view.create_one(spec, unique: false)).to be_successful
+      end
+    end
+
+    context 'when providing an index name' do
+
+      let(:spec) do
+        { random: 1 }
+      end
+
+      let!(:result) do
+        view.create_one(spec, unique: true, name: 'random_name')
+      end
+
+      after do
+        view.drop_one('random_name')
+      end
+
+      it 'returns ok' do
+        expect(result).to be_successful
+      end
+
+      it 'defines the index with the provided name' do
+        expect(view.get('random_name')).to_not be_nil
+      end
+    end
+  end
+
+  describe '#get' do
+
+    let(:spec) do
+      { random: 1 }
+    end
+
+    let!(:result) do
+      view.create_one(spec, unique: true, name: 'random_name')
+    end
+
+    after do
+      view.drop_one('random_name')
+    end
+
+    context 'when providing a name' do
+
+      let(:index) do
+        view.get('random_name')
+      end
+
+      it 'returns the index' do
+        expect(index['name']).to eq('random_name')
+      end
+    end
+
+    context 'when providing a spec' do
+
+      let(:index) do
+        view.get(random: 1)
+      end
+
+      it 'returns the index' do
+        expect(index['name']).to eq('random_name')
+      end
+    end
+
+    context 'when the index does not exist' do
+
+      it 'returns nil' do
+        expect(view.get(other: 1)).to be_nil
+      end
+    end
+  end
+
+  describe '#each' do
+
+    context 'when the collection exists' do
+
+      let(:spec) do
+        { name: 1 }
+      end
+
+      before do
+        view.create_one(spec, unique: true)
+      end
+
+      after do
+        view.drop_one('name_1')
+      end
+
+      let(:indexes) do
+        view.each
+      end
+
+      it 'returns all the indexes for the database' do
+        expect(indexes.to_a.count).to eq(2)
+      end
+    end
+
+    context 'when the collection does not exist' do
+
+      let(:nonexistant_collection) do
+        authorized_client[:not_a_collection]
+      end
+
+      let(:nonexistant_view) do
+        described_class.new(nonexistant_collection)
+      end
+
+      it 'raises a nonexistant collection error', if: list_command_enabled? do
+        expect {
+          nonexistant_view.each.to_a
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+
+  describe '#normalize_models' do
+
+    context 'when providing options' do
+
+      let(:options) do
+        {
+          :key => { :name => 1 },
+          :bucket_size => 5,
+          :default_language => 'deutsch',
+          :expire_after => 10,
+          :language_override => 'language',
+          :sphere_version => 1,
+          :storage_engine => 'wiredtiger',
+          :text_version => 2,
+          :version => 1
+        }
+      end
+
+      let(:models) do
+        view.send(:normalize_models, [ options ])
+      end
+
+      let(:expected) do
+        {
+          :key => { :name => 1 },
+          :name => 'name_1',
+          :bucketSize => 5,
+          :default_language => 'deutsch',
+          :expireAfterSeconds => 10,
+          :language_override => 'language',
+          :'2dsphereIndexVersion' => 1,
+          :storageEngine => 'wiredtiger',
+          :textIndexVersion => 2,
+          :v => 1
+        }
+      end
+
+      it 'maps the ruby options to the server options' do
+        expect(models).to eq([ expected ])
+      end
+    end
+  end
+end

data/spec/mongo/loggable_spec.rb

@@ -0,0 +1,62 @@
+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
+      expect(operation).to receive(:log_message).and_return('test')
+      expect(Mongo::Logger).to receive(:debug).with('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/logger_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Mongo::Logger do
+
+  let(:logger) do
+    described_class.logger
+  end
+
+  describe '.debug' do
+
+    it 'logs a debug message' do
+      expect(logger).to receive(:debug).with("mongo.query | message | runtime: 10ms")
+      described_class.debug('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.error' do
+
+    it 'logs a error message' do
+      expect(logger).to receive(:error).with("mongo.query | message | runtime: 10ms")
+      described_class.error('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.fatal' do
+
+    it 'logs a fatal message' do
+      expect(logger).to receive(:fatal).with("mongo.query | message | runtime: 10ms")
+      described_class.fatal('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.info' do
+
+    it 'logs a info message' do
+      expect(logger).to receive(:info).with("mongo.query | message | runtime: 10ms")
+      described_class.info('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.logger' do
+
+    context 'when no logger has been set' do
+
+      let(:test_logger) do
+        Mongo::Logger.logger
+      end
+
+      before do
+        Mongo::Logger.logger = nil
+      end
+
+      after do
+        Mongo::Logger.logger = test_logger
+      end
+
+      it 'returns the default logger' do
+        expect(logger.level).to eq(Logger::DEBUG)
+      end
+    end
+
+    context 'when a logger has been set' do
+
+      let(:info) do
+        Logger.new($stdout).tap do |log|
+          log.level = Logger::INFO
+        end
+      end
+
+      let(:debug) do
+        Logger.new($stdout).tap do |log|
+          log.level = Logger::DEBUG
+        end
+      end
+
+      before do
+        described_class.logger = debug
+      end
+
+      after do
+        described_class.logger = info
+      end
+
+      it 'returns the provided logger' do
+        expect(logger.level).to eq(Logger::DEBUG)
+      end
+    end
+  end
+
+  describe '.warn' do
+
+    it 'logs a warn message' do
+      expect(logger).to receive(:warn).with("mongo.query | message | runtime: 10ms")
+      described_class.warn('mongo.query', 'message', '10ms')
+    end
+  end
+end

data/spec/mongo/operation/aggregate/result_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Aggregate::Result do
+
+  let(:result) do
+    described_class.new(reply)
+  end
+
+  let(:cursor_id) { 0 }
+  let(:documents) { [] }
+  let(:flags) { [] }
+  let(:starting_from) { 0 }
+
+  let(:reply) do
+    Mongo::Protocol::Reply.new.tap do |reply|
+      reply.instance_variable_set(:@flags, flags)
+      reply.instance_variable_set(:@cursor_id, cursor_id)
+      reply.instance_variable_set(:@starting_from, starting_from)
+      reply.instance_variable_set(:@number_returned, documents.size)
+      reply.instance_variable_set(:@documents, documents)
+    end
+  end
+
+  let(:aggregate) do
+    [
+      { '_id' => 'New York', 'totalpop' => 40270 },
+      { '_id' => 'Berlin', 'totalpop' => 103056 }
+    ]
+  end
+
+  describe '#cursor_id' do
+
+    context 'when the result is not using a cursor' do
+
+      let(:documents) do
+        [{ 'result' => aggregate, 'ok' => 1.0 }]
+      end
+
+      it 'returns zero' do
+        expect(result.cursor_id).to eq(0)
+      end
+    end
+
+    context 'when the result is using a cursor' do
+
+      let(:documents) do
+        [{ 'cursor' => { 'id' => 15, 'ns' => 'test', 'firstBatch' => aggregate }, 'ok' => 1.0 }]
+      end
+
+      it 'returns the cursor id' do
+        expect(result.cursor_id).to eq(15)
+      end
+    end
+  end
+
+  describe '#documents' do
+
+    context 'when the result is not using a cursor' do
+
+      let(:documents) do
+        [{ 'result' => aggregate, 'ok' => 1.0 }]
+      end
+
+      it 'returns the documents' do
+        expect(result.documents).to eq(aggregate)
+      end
+    end
+
+    context 'when the result is using a cursor' do
+
+      let(:documents) do
+        [{ 'cursor' => { 'id' => 15, 'ns' => 'test', 'firstBatch' => aggregate }, 'ok' => 1.0 }]
+      end
+
+      it 'returns the documents' do
+        expect(result.documents).to eq(aggregate)
+      end
+    end
+  end
+end

data/spec/mongo/operation/aggregate_spec.rb

@@ -0,0 +1,127 @@
+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