mongo 2.0.4 → 2.0.5

data/spec/mongo/client_spec.rb

@@ -569,4 +569,23 @@ describe Mongo::Client do
       end
     end
   end
+
+  describe '#database_names' do
+
+    it 'returns a list of database names' do
+      expect(root_authorized_client.database_names).to include(
+        'admin'
+      )
+    end
+  end
+
+  describe '#list_databases' do
+
+    it 'returns a list of database info documents' do
+      expect(
+        root_authorized_client.list_databases.collect do |i|
+          i['name']
+        end).to include('admin')
+    end
+  end
 end

data/spec/mongo/cluster_spec.rb

@@ -76,7 +76,8 @@ describe Mongo::Cluster do
     context 'when the option is provided' do
 
       let(:cluster) do
-        described_class.new([ '127.0.0.1:27017' ], TEST_OPTIONS.merge(:replica_set => 'testing'))
+        described_class.new([ '127.0.0.1:27017' ], TEST_OPTIONS.merge(:connect => :replica_set,
+                                                                      :replica_set => 'testing'))
       end
 
       it 'returns the name' do

data/spec/mongo/collection/view/aggregation_spec.rb

@@ -39,7 +39,7 @@ describe Mongo::Collection::View::Aggregation do
 
   describe '#each' do
 
-     let(:documents) do
+    let(:documents) do
       [
         { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
         { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
@@ -145,4 +145,37 @@ describe Mongo::Collection::View::Aggregation do
       expect(aggregation.options).not_to be(options)
     end
   end
+
+  describe '#explain' do
+
+    it 'executes an explain' do
+      expect(aggregation.explain).to_not be_empty
+    end
+  end
+
+  describe '#aggregate_spec' do
+
+    context 'when the collection has a read preference' do
+
+      let(:read_preference) do
+        Mongo::ServerSelector.get(mode: :secondary)
+      end
+
+      it 'includes the read preference in the spec' do
+        allow(authorized_collection).to receive(:read_preference).and_return(read_preference)
+        expect(aggregation.send(:aggregate_spec)[:read]).to eq(read_preference)
+      end
+    end
+
+    context 'when allow_disk_use is set' do
+
+      let(:aggregation) do
+        described_class.new(view, pipeline, options).allow_disk_use(true)
+      end
+
+      it 'includes the option in the spec' do
+        expect(aggregation.send(:aggregate_spec)[:selector][:allowDiskUse]).to eq(true)
+      end
+    end
+  end
 end

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -150,6 +150,10 @@ describe Mongo::Collection::View::MapReduce do
             expect(document[:_id]).to eq('Berlin')
           end
         end
+
+        it 'includes the selector in the operation spec' do
+          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(selector)
+        end
       end
 
       context 'when the selector is advanced' do
@@ -163,6 +167,10 @@ describe Mongo::Collection::View::MapReduce do
             expect(document[:_id]).to eq('Berlin')
           end
         end
+
+        it 'includes the selector in the operation spec' do
+          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(selector[:$query])
+        end
       end
     end
 
@@ -197,6 +205,10 @@ describe Mongo::Collection::View::MapReduce do
     it 'sets the finalize function' do
       expect(new_map_reduce.finalize).to eq(finalize)
     end
+
+    it 'includes the finalize function in the operation spec' do
+      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:finalize]).to eq(finalize)
+    end
   end
 
   describe '#js_mode' do
@@ -208,6 +220,10 @@ describe Mongo::Collection::View::MapReduce do
     it 'sets the js mode value' do
       expect(new_map_reduce.js_mode).to be true
     end
+
+    it 'includes the js mode value in the operation spec' do
+      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:jsMode]).to be(true)
+    end
   end
 
   describe '#out' do
@@ -223,6 +239,17 @@ describe Mongo::Collection::View::MapReduce do
     it 'sets the out value' do
       expect(new_map_reduce.out).to eq(location)
     end
+
+    it 'includes the out value in the operation spec' do
+      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:out]).to be(location)
+    end
+
+    context 'when out is not defined' do
+
+      it 'defaults to inline' do
+        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq(inline: 1)
+      end
+    end
   end
 
   describe '#scope' do
@@ -238,5 +265,70 @@ describe Mongo::Collection::View::MapReduce do
     it 'sets the scope object' do
       expect(new_map_reduce.scope).to eq(object)
     end
+
+    it 'includes the scope object in the operation spec' do
+      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:scope]).to be(object)
+    end
+  end
+
+  describe '#verbose' do
+
+    let(:verbose) do
+      false
+    end
+
+    let(:new_map_reduce) do
+      map_reduce.verbose(verbose)
+    end
+
+    it 'sets the verbose value' do
+      expect(new_map_reduce.verbose).to be(false)
+    end
+
+    it 'includes the verbose option in the operation spec' do
+      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:verbose]).to eq(verbose)
+    end
+  end
+
+  context 'when limit is set on the view' do
+
+    let(:limit) do
+      3
+    end
+
+    let(:view_options) do
+      { limit: limit }
+    end
+
+    it 'includes the limit in the operation spec' do
+      expect(map_reduce.send(:map_reduce_spec)[:selector][:limit]).to be(limit)
+    end
+  end
+
+  context 'when sort is set on the view' do
+
+    let(:sort) do
+      { name: -1 }
+    end
+
+    let(:view_options) do
+      { sort: sort }
+    end
+
+    it 'includes the sort object in the operation spec' do
+      expect(map_reduce.send(:map_reduce_spec)[:selector][:sort]).to be(sort)
+    end
+  end
+
+  context 'when the collection has a read preference' do
+
+    let(:read_preference) do
+      Mongo::ServerSelector.get(mode: :secondary)
+    end
+
+    it 'includes the read preference in the spec' do
+      allow(authorized_collection).to receive(:read_preference).and_return(read_preference)
+      expect(map_reduce.send(:map_reduce_spec)[:read]).to eq(read_preference)
+    end
   end
 end

data/spec/mongo/collection/view_spec.rb

@@ -334,19 +334,22 @@ describe Mongo::Collection::View do
 
       context 'when providing a hint' do
 
-        let(:options) do
-          { :hint => { 'x' => Mongo::Index::ASCENDING }}
-        end
+        context 'when the hint is bad' do
 
-        before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:selector][:$query]).to eq(selector)
-          end.and_call_original
-        end
+          let(:options) do
+            { :hint => { 'x' => Mongo::Index::ASCENDING }}
+          end
 
-        it'creates a special query selector' do
-          view.each do |doc|
-            expect(doc).to have_key('$err')
+          before do
+            expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
+              expect(spec[:selector][:$query]).to eq(selector)
+            end.and_call_original
+          end
+
+          it'creates a special query selector' do
+            expect {
+              view.to_a
+            }.to raise_error(Mongo::Error::OperationFailure)
           end
         end
       end

data/spec/mongo/collection_spec.rb

@@ -262,6 +262,19 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when providing a bad selector' do
+
+      let(:view) do
+        authorized_collection.find('$or' => [])
+      end
+
+      it 'raises an exception when iterating' do
+        expect {
+          view.to_a
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
     context 'when iterating the authorized_collection view' do
 
       before do

data/spec/mongo/database_spec.rb

@@ -95,6 +95,35 @@ describe Mongo::Database do
     end
   end
 
+  describe '#list_collections' do
+
+    let(:database) do
+      described_class.new(authorized_client, TEST_DB)
+    end
+
+    let(:result) do
+      database.list_collections.map do |info|
+        info['name']
+      end
+    end
+
+    before do
+      database[:users].create
+    end
+
+    after do
+      database[:users].drop
+    end
+
+    it 'returns a list of the collections info', if: list_command_enabled?  do
+      expect(result).to include('users')
+    end
+
+    it 'returns a list of the collections info', unless: list_command_enabled?  do
+      expect(result).to include("#{TEST_DB}.users")
+    end
+  end
+
   describe '#collections' do
 
     context 'when the database exists' do

data/spec/mongo/grid/fs_spec.rb

@@ -65,7 +65,7 @@ describe Mongo::Grid::FS do
 
     context 'when inserting the file once' do
 
-      before do
+      let!(:result) do
         fs.insert_one(file)
       end
 
@@ -85,6 +85,10 @@ describe Mongo::Grid::FS do
       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
@@ -101,6 +105,33 @@ describe Mongo::Grid::FS do
         }.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

data/spec/mongo/loggable_spec.rb

@@ -23,8 +23,9 @@ describe Mongo::Loggable do
     end
 
     before do
+      Mongo::Logger.level = Logger::DEBUG
       expect(operation).to receive(:log_message).and_return('test')
-      expect(Mongo::Logger).to receive(:debug).with('MONGO', 'test', anything())
+      expect(Mongo::Logger).to receive(:log).with(:debug, 'MONGO', 'test', anything())
     end
 
     context 'when a block is provided' do

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

@@ -58,6 +58,25 @@ describe Mongo::Operation::Read::Query do
     end
   end
 
+  describe '#message' do
+
+    let(:query_options) do
+      { :flags => [ :no_cursor_timeout ]}
+    end
+
+    let(:query) do
+      described_class.new(spec)
+    end
+
+    let(:message) do
+      query.send(:message, secondary_context_slave)
+    end
+
+    it 'does not lose flags' do
+      expect(message.flags).to eq([ :no_cursor_timeout, :slave_ok ])
+    end
+  end
+
   describe '#execute' do
 
     context 'message' do

data/spec/mongo/operation/read_preferrable_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Mongo::Operation::ReadPreferrable do
+
+  let(:selector) do
+    { name: 'test' }
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:mongos) do
+    false
+  end
+
+  let(:slave_ok) do
+    false
+  end
+
+  let(:read_preferrable) do
+    Class.new do
+      include Mongo::Operation::ReadPreferrable
+    end.new.tap do |rp|
+      allow(rp).to receive(:read).and_return(read_pref)
+      allow(rp).to receive(:selector).and_return(selector)
+      allow(rp).to receive(:options).and_return(options)
+    end
+  end
+
+  let(:context) do
+    double('context').tap do |c|
+      allow(c).to receive(:slave_ok?).and_return(slave_ok)
+      allow(c).to receive(:mongos?).and_return(mongos)
+    end
+  end
+
+  shared_context 'a selector updater' do
+
+    let(:read_pref) do
+      Mongo::ServerSelector.get(:mode => mode)
+    end
+
+    let(:expected) do
+      { :$query => selector, :$readPreference => read_pref.to_mongos }
+    end
+
+    it 'returns a special selector' do
+      expect(read_preferrable.send(:update_selector, context)).to eq(expected)
+    end
+
+    context 'when the selector already has $query in it' do
+
+      let(:selector) do
+        { :$query => { :name => 'test' },
+          :$orderby => { :name => -1 } }
+      end
+
+      let(:expected) do
+        selector.merge(:$readPreference => read_pref.to_mongos)
+      end
+
+      it 'returns a special selector' do
+        expect(read_preferrable.send(:update_selector, context)).to eq(expected)
+      end
+    end
+  end
+
+  shared_context 'not a selector updater' do
+
+    let(:read_pref) do
+      Mongo::ServerSelector.get(:mode => mode)
+    end
+
+    it 'returns a special selector' do
+      expect(read_preferrable.send(:update_selector, context)).to eq(selector)
+    end
+  end
+
+  context 'when the server is a mongos' do
+
+    let(:mongos) do
+      true
+    end
+
+    context 'when the read preference mode is primary' do
+
+      let(:mode) do
+        :primary
+      end
+
+      it_behaves_like 'not a selector updater'
+    end
+
+    context 'when the read preference mode is primary_preferred' do
+
+      let(:mode) do
+        :primary_preferred
+      end
+
+      it_behaves_like 'a selector updater'
+    end
+
+    context 'when the read preference mode is secondary' do
+
+      let(:mode) do
+        :secondary
+      end
+
+      it_behaves_like 'a selector updater'
+    end
+
+    context 'when the read preference mode is secondary_preferred' do
+
+      let(:mode) do
+        :secondary_preferred
+      end
+
+      it_behaves_like 'not a selector updater'
+    end
+
+    context 'when the read preference mode is nearest' do
+
+      let(:mode) do
+        :nearest
+      end
+
+      it_behaves_like 'a selector updater'
+    end
+  end
+
+  context 'when the server is not a mongos' do
+
+    let(:mode) do
+      :secondary_preferred
+    end
+
+    it_behaves_like 'not a selector updater'
+  end
+
+  context 'when the server context requires the slaveOk bit to be set' do
+
+    let(:read_pref) do
+      Mongo::ServerSelector.get(:mode => :secondary)
+    end
+
+    let(:expected) do
+      { :flags => [ :slave_ok ] }
+    end
+
+    let(:slave_ok) do
+      true
+    end
+
+    it 'sets the slave_ok flag' do
+      expect(read_preferrable.send(:update_options, context)).to eq(expected)
+    end
+  end
+
+  context 'when the server is not a mongos' do
+
+    context 'when the read preference requires the slaveOk bit to be set' do
+
+      let(:read_pref) do
+        Mongo::ServerSelector.get(:mode => :secondary)
+      end
+
+      let(:expected) do
+        { :flags => [ :slave_ok ] }
+      end
+
+      it 'sets the slave_ok flag' do
+        expect(read_preferrable.send(:update_options, context)).to eq(expected)
+      end
+    end
+
+    context 'when the read preference does not require the slaveOk bit to be set' do
+
+      let(:read_pref) do
+        Mongo::ServerSelector.get(:mode => :primary)
+      end
+
+      let(:expected) do
+        { }
+      end
+
+      it 'sets the slave_ok flag' do
+        expect(read_preferrable.send(:update_options, context)).to eq(expected)
+      end
+    end
+  end
+end