mongo 2.0.6 → 2.1.0

data/spec/mongo/grid/stream_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Mongo::Grid::FSBucket::Stream do
+
+  let(:fs) do
+    authorized_client.database.fs
+  end
+
+  describe '.get' do
+
+    let(:stream) do
+      described_class.get(fs, mode)
+    end
+
+    context 'when mode is read' do
+
+      let(:mode) do
+        Mongo::Grid::FSBucket::Stream::READ_MODE
+      end
+
+      it 'returns a Stream::Read object' do
+        expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Read)
+      end
+    end
+
+    context 'when mode is write' do
+
+      let(:mode) do
+        Mongo::Grid::FSBucket::Stream::WRITE_MODE
+      end
+
+      it 'returns a Stream::Write object' do
+        expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Write)
+      end
+
+      context 'when options are provided' do
+
+        let(:stream) do
+          described_class.get(fs, mode, chunk_size: 100)
+        end
+
+        it 'sets the options on the stream object' do
+          expect(stream.options[:chunk_size]).to eq(100)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/gridfs_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'GridFS' do
+  include Mongo::GridFS
+
+  GRIDFS_TESTS.each do |file|
+
+    spec = Mongo::GridFS::Spec.new(file)
+
+    context(spec.description) do
+
+      spec.tests.each do |test|
+
+        context(test.description) do
+
+          after do
+            fs.files_collection.delete_many
+            fs.chunks_collection.delete_many
+            test.expected_files_collection.delete_many
+            test.expected_chunks_collection.delete_many
+          end
+
+          let!(:result) do
+            test.run(fs)
+          end
+
+          let(:fs) do
+            authorized_collection.database.fs
+          end
+
+          it "raises the correct error", if: test.error? do
+            expect(result).to match_error(test.expected_error)
+          end
+
+          it 'completes successfully', unless: test.error? do
+            expect(result).to completes_successfully(test)
+          end
+
+          it 'has the correct documents in the files collection', if: test.assert_data? do
+            expect(fs.files_collection).to match_files_collection(test.expected_files_collection)
+          end
+
+          it 'has the correct documents in the chunks collection', if: test.assert_data? do
+            expect(fs.chunks_collection).to match_chunks_collection(test.expected_chunks_collection)
+          end
+        end
+      end
+    end 
+  end
+end

data/spec/mongo/logger_spec.rb

@@ -6,38 +6,6 @@ describe Mongo::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
@@ -86,12 +54,4 @@ describe Mongo::Logger do
       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/monitoring/command_log_subscriber_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Mongo::Monitoring::CommandLogSubscriber do
+
+  describe '#started' do
+
+    let(:filter) do
+      (1...100).reduce({}) do |hash, i|
+        hash[i] = i
+        hash
+      end
+    end
+
+    let(:command) do
+      { find: 'users', filter: filter }
+    end
+
+    let(:event) do
+      Mongo::Monitoring::Event::CommandStarted.new(
+        'find',
+        'users',
+        Mongo::Address.new('127.0.0.1:27017'),
+        12345,
+        67890,
+        command
+      )
+    end
+
+    before do
+      Mongo::Logger.level = Logger::DEBUG
+    end
+
+    after do
+      Mongo::Logger.level = Logger::INFO
+    end
+
+    context 'when truncating the logs' do
+
+      context 'when no option is provided' do
+
+        let(:subscriber) do
+          described_class.new
+        end
+
+        it 'truncates the logs at 250 characters' do
+          expect(subscriber).to receive(:truncate).with(command).and_call_original
+          subscriber.started(event)
+        end
+      end
+
+      context 'when true option is provided' do
+
+        let(:subscriber) do
+          described_class.new(truncate_logs: true)
+        end
+
+        it 'truncates the logs at 250 characters' do
+          expect(subscriber).to receive(:truncate).with(command).and_call_original
+          subscriber.started(event)
+        end
+      end
+    end
+
+    context 'when not truncating the logs' do
+
+      let(:subscriber) do
+        described_class.new(truncate_logs: false)
+      end
+
+      it 'does not truncate the logs' do
+        expect(subscriber).to_not receive(:truncate)
+        subscriber.started(event)
+      end
+    end
+  end
+end

data/spec/mongo/monitoring/event/command_started_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Mongo::Monitoring::Event::CommandStarted do
+
+  describe '#initialize' do
+
+    let(:address) do
+      Mongo::Address.new('127.0.0.1:27017')
+    end
+
+    let(:command) do
+      BSON::Document.new(test: 'value')
+    end
+
+    context 'when the command should be redacted' do
+
+      let(:event) do
+        described_class.new('copydb', 'admin', address, 1, 2, command)
+      end
+
+      it 'sets the command to an empty document' do
+        expect(event.command).to be_empty
+      end
+    end
+  end
+end

data/spec/mongo/monitoring/event/command_succeeded_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Mongo::Monitoring::Event::CommandSucceeded do
+
+  describe '#initialize' do
+
+    let(:address) do
+      Mongo::Address.new('127.0.0.1:27017')
+    end
+
+    let(:reply) do
+      BSON::Document.new(test: 'value')
+    end
+
+    context 'when the reply should be redacted' do
+
+      let(:event) do
+        described_class.new('copydb', 'admin', address, 1, 2, reply, 0.5)
+      end
+
+      it 'sets the reply to an empty document' do
+        expect(event.reply).to be_empty
+      end
+    end
+  end
+end

data/spec/mongo/monitoring/event/secure_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Mongo::Monitoring::Event::Secure do
+
+  let(:document) do
+    BSON::Document.new(test: 'value')
+  end
+
+  let(:klass) do
+    Class.new do
+      include Mongo::Monitoring::Event::Secure
+    end
+  end
+
+  describe '#redacted' do
+
+    let(:secure) do
+      klass.new
+    end
+
+    context 'when the command must be redacted' do
+
+      context 'when the command name is a string' do
+
+        let(:redacted) do
+          secure.redacted('saslStart', document)
+        end
+
+        it 'returns an empty document' do
+          expect(redacted).to be_empty
+        end
+      end
+
+      context 'when the command name is a symbol' do
+
+        let(:redacted) do
+          secure.redacted(:saslStart, document)
+        end
+
+        it 'returns an empty document' do
+          expect(redacted).to be_empty
+        end
+      end
+    end
+
+    context 'when the command is not in the redacted list' do
+
+      let(:redacted) do
+        secure.redacted(:find, document)
+      end
+
+      it 'returns the document' do
+        expect(redacted).to eq(document)
+      end
+    end
+  end
+end

data/spec/mongo/monitoring_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Mongo::Monitoring do
+
+  describe '#dup' do
+
+    let(:monitoring) do
+      described_class.new
+    end
+
+    let(:copy) do
+      monitoring.dup
+    end
+
+    it 'dups the subscribers' do
+      expect(monitoring.subscribers).to_not equal(copy.subscribers)
+    end
+
+    it 'keeps the same subscriber instances' do
+      expect(monitoring.subscribers).to eq(copy.subscribers)
+    end
+
+    context 'when adding to the copy' do
+
+      let(:subscriber) do
+        double('subscriber')
+      end
+
+      before do
+        copy.subscribe('topic', subscriber)
+      end
+
+      it 'does not modify the original subscribers' do
+        expect(monitoring.subscribers).to_not eq(copy.subscribers)
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    context 'when no monitoring options provided' do
+
+      let(:monitoring) do
+        described_class.new
+      end
+
+      it 'includes the global subscribers' do
+        expect(monitoring.subscribers.size).to eq(1)
+      end
+    end
+
+    context 'when monitoring options provided' do
+
+      context 'when monitoring is true' do
+
+        let(:monitoring) do
+          described_class.new(monitoring: true)
+        end
+
+        it 'includes the global subscribers' do
+          expect(monitoring.subscribers.size).to eq(1)
+        end
+      end
+
+      context 'when monitoring is false' do
+
+        let(:monitoring) do
+          described_class.new(monitoring: false)
+        end
+
+        it 'does not include the global subscribers' do
+          expect(monitoring.subscribers).to be_empty
+        end
+      end
+    end
+  end
+
+  describe '#subscribe' do
+
+    let(:monitoring) do
+      described_class.new(monitoring: false)
+    end
+
+    let(:subscriber) do
+      double('subscriber')
+    end
+
+    before do
+      monitoring.subscribe('topic', subscriber)
+    end
+
+    it 'subscribes to the topic' do
+      expect(monitoring.subscribers['topic']).to eq([ subscriber ])
+    end
+  end
+
+  describe '#started' do
+
+    let(:monitoring) do
+      described_class.new(monitoring: false)
+    end
+
+    let(:subscriber) do
+      double('subscriber')
+    end
+
+    let(:event) do
+      double('event')
+    end
+
+    before do
+      monitoring.subscribe('topic', subscriber)
+    end
+
+    it 'calls the started method on each subscriber' do
+      expect(subscriber).to receive(:started).with(event)
+      monitoring.started('topic', event)
+    end
+  end
+
+  describe '#succeeded' do
+
+    let(:monitoring) do
+      described_class.new(monitoring: false)
+    end
+
+    let(:subscriber) do
+      double('subscriber')
+    end
+
+    let(:event) do
+      double('event')
+    end
+
+    before do
+      monitoring.subscribe('topic', subscriber)
+    end
+
+    it 'calls the succeeded method on each subscriber' do
+      expect(subscriber).to receive(:succeeded).with(event)
+      monitoring.succeeded('topic', event)
+    end
+  end
+
+  describe '#failed' do
+
+    let(:monitoring) do
+      described_class.new(monitoring: false)
+    end
+
+    let(:subscriber) do
+      double('subscriber')
+    end
+
+    let(:event) do
+      double('event')
+    end
+
+    before do
+      monitoring.subscribe('topic', subscriber)
+    end
+
+    it 'calls the failed method on each subscriber' do
+      expect(subscriber).to receive(:failed).with(event)
+      monitoring.failed('topic', event)
+    end
+  end
+end

data/spec/mongo/operation/commands/aggregate_spec.rb

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

data/spec/mongo/operation/{read → commands}/collections_info_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mongo::Operation::Read::CollectionsInfo do
+describe Mongo::Operation::CollectionsInfo do
 
   let(:spec) do
     { :db_name => TEST_DB }

data/spec/mongo/operation/{command_spec.rb → commands/command_spec.rb}

@@ -38,24 +38,6 @@ describe Mongo::Operation::Command do
     end
   end
 
-  context '#merge' do
-
-    let(:other_op) { described_class.new(spec) }
-
-    it 'raises an exception' do
-      expect{ op.merge(other_op) }.to raise_exception
-    end
-  end
-
-  context '#merge!' do
-
-    let(:other_op) { described_class.new(spec) }
-
-    it 'raises an exception' do
-      expect{ op.merge!(other_op) }.to raise_exception
-    end
-  end
-
   describe '#execute' do
 
     context 'when the command succeeds' do

data/spec/mongo/operation/{read → commands}/indexes_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mongo::Operation::Read::Indexes do
+describe Mongo::Operation::Indexes do
 
   describe '#execute' do
 

data/spec/mongo/operation/{map_reduce_spec.rb → commands/map_reduce_spec.rb}

@@ -77,24 +77,6 @@ describe Mongo::Operation::MapReduce do
     end
   end
 
-  describe '#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 '#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
 
     let(:documents) do
@@ -109,7 +91,7 @@ describe Mongo::Operation::MapReduce do
     end
 
     after do
-      authorized_collection.find.delete_many
+      authorized_collection.delete_many
     end
 
     context 'when the map/reduce succeeds' do

data/spec/mongo/operation/kill_cursors_spec.rb

@@ -27,28 +27,12 @@ describe Mongo::Operation::KillCursors do
     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 'message' do
 
       it 'creates a kill cursors wire protocol message with correct specs' do
-        expect(Mongo::Protocol::KillCursors).to receive(:new) do |ids|
+        expect(Mongo::Protocol::KillCursors).to receive(:new) do |collection, database, ids|
           expect(ids).to eq(spec[:cursor_ids])
         end
         op.execute(primary_context)

data/spec/mongo/operation/read/get_more_spec.rb

@@ -39,22 +39,6 @@ describe Mongo::Operation::Read::GetMore do
     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 'message' do