mongo 2.1.0.beta → 2.2.0

data/spec/mongo/command_monitoring_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+def skippable?(file)
+  !write_command_enabled? && (file.include?('bulkWrite') || file.include?('insert'))
+end
+
+def ignore?(test)
+  if version = test.ignore_if_server_version_greater_than
+    return true if version == "3.0" && find_command_enabled?
+  end
+  if version = test.ignore_if_server_version_less_than
+    return true if version == "3.1" && !find_command_enabled?
+  end
+  false
+end
+
+describe 'Command Monitoring Events' do
+
+  COMMAND_MONITORING_TESTS.each do |file|
+
+    if !skippable?(file)
+
+      spec = Mongo::CommandMonitoring::Spec.new(file)
+
+      spec.tests.each do |test|
+
+        context(test.description) do
+
+          let(:subscriber) do
+            Mongo::CommandMonitoring::TestSubscriber.new
+          end
+
+          let(:monitoring) do
+            authorized_client.instance_variable_get(:@monitoring)
+          end
+
+          before do
+            authorized_collection.find.delete_many
+            authorized_client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+          end
+
+          after do
+            monitoring.subscribers[Mongo::Monitoring::COMMAND].delete(subscriber)
+            authorized_collection.find.delete_many
+          end
+
+          test.expectations.each do |expectation|
+
+            it "generates a #{expectation.event_name} for #{expectation.command_name}", unless: ignore?(test) do
+              begin
+                test.run(authorized_collection)
+                event = subscriber.send(expectation.event_type)[expectation.command_name]
+                expect(event).to send(expectation.matcher, expectation)
+              rescue Mongo::Error::OperationFailure, Mongo::Error::BulkWriteError => e
+                event = subscriber.send(expectation.event_type)[expectation.command_name]
+                expect(event).to send(expectation.matcher, expectation)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/connection_string_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe 'ConnectionString' do
+  include Mongo::ConnectionString
+
+  CONNECTION_STRING_TESTS.each do |file|
+
+    spec = Mongo::ConnectionString::Spec.new(file)
+
+    context(spec.description) do
+
+      before(:all) do
+
+        module Mongo
+          class Address
+
+            private
+
+            alias :original_initialize_resolver! :initialize_resolver!
+            def initialize_resolver!(timeout, ssl_options)
+              family = (host == 'localhost') ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
+              info = ::Socket.getaddrinfo(host, nil, family, ::Socket::SOCK_STREAM)
+              FAMILY_MAP[info.first[4]].new(info[3], port, host)
+            end
+          end
+
+          class Server
+
+            # The constructor keeps the same API, but does not instantiate a
+            # monitor and run it.
+            alias :original_initialize :initialize
+            def initialize(address, cluster, monitoring, event_listeners, options = {})
+              @address = address
+              @cluster = cluster
+              @monitoring = monitoring
+              @options = options.freeze
+              @monitor = Monitor.new(address, event_listeners, options)
+            end
+
+            # Disconnect simply needs to return true since we have no monitor and
+            # no connection.
+            alias :original_disconnect! :disconnect!
+            def disconnect!; true; end
+          end
+        end
+      end
+
+      after(:all) do
+
+        module Mongo
+          # Return the implementations to their originals for the other
+          # tests in the suite.
+          class Address
+            alias :initialize_resolver! :original_initialize_resolver!
+            remove_method(:original_initialize_resolver!)
+          end
+
+          class Server
+            alias :initialize :original_initialize
+            remove_method(:original_initialize)
+
+            alias :disconnect! :original_disconnect!
+            remove_method(:original_disconnect!)
+          end
+        end
+      end
+
+      spec.tests.each_with_index do |test, index|
+
+        context "when a #{test.description} is provided" do
+
+
+          context 'when the uri is invalid', unless: test.valid? do
+
+            it 'raises an error' do
+              expect{
+                test.uri
+              }.to raise_exception(Mongo::Error::InvalidURI)
+            end
+          end
+
+          context 'when the uri should warn', if: test.warn? do
+
+            before do
+              expect(Mongo::Logger.logger).to receive(:warn)
+            end
+
+            it 'warns' do
+              expect(test.client).to be_a(Mongo::Client)
+            end
+          end
+
+          context 'when the uri is valid', if: test.valid? do
+
+            it 'does not raise an exception' do
+              expect(test.uri).to be_a(Mongo::URI)
+            end
+
+            it 'creates a client with the correct hosts' do
+              expect(test.client).to have_hosts(test)
+            end
+
+            it 'creates a client with the correct authentication properties' do
+              expect(test.client).to match_auth(test)
+            end
+
+            it 'creates a client with the correct options' do
+              expect(test.client).to match_options(test)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe Mongo::Cursor::Builder::GetMoreCommand do
+
+  describe '#specification' do
+
+    let(:reply) do
+      Mongo::Protocol::Reply.allocate
+    end
+
+    let(:result) do
+      Mongo::Operation::Result.new(reply)
+    end
+
+    let(:cursor) do
+      Mongo::Cursor.new(view, result, authorized_primary)
+    end
+
+    let(:builder) do
+      described_class.new(cursor)
+    end
+
+    let(:specification) do
+      builder.specification
+    end
+
+    let(:selector) do
+      specification[:selector]
+    end
+
+    shared_examples_for 'a getmore command builder' do
+
+      it 'includes the database name' do
+        expect(specification[:db_name]).to eq(TEST_DB)
+      end
+
+      it 'includes getmore with cursor id' do
+        expect(selector[:getMore]).to eq(cursor.id)
+      end
+
+      it 'includes the collection name' do
+        expect(selector[:collection]).to eq(TEST_COLL)
+      end
+    end
+
+    context 'when the query is standard' do
+
+      let(:view) do
+        Mongo::Collection::View.new(authorized_collection)
+      end
+
+      it_behaves_like 'a getmore command builder'
+
+      it 'does not include max time' do
+        expect(selector[:maxTimeMS]).to be_nil
+      end
+
+      it 'does not include batch size' do
+        expect(selector[:batchSize]).to be_nil
+      end
+    end
+
+    context 'when the query has a batch size' do
+
+      let(:view) do
+        Mongo::Collection::View.new(authorized_collection, {}, batch_size: 10)
+      end
+
+      it_behaves_like 'a getmore command builder'
+
+      it 'does not include max time' do
+        expect(selector[:maxTimeMS]).to be_nil
+      end
+
+      it 'includes batch size' do
+        expect(selector[:batchSize]).to eq(10)
+      end
+    end
+
+    context 'when a max await time is specified' do
+
+      context 'when the cursor is not tailable' do
+
+        let(:view) do
+          Mongo::Collection::View.new(authorized_collection, {}, max_await_time_ms: 100)
+        end
+
+        it_behaves_like 'a getmore command builder'
+
+        it 'does not include max time' do
+          expect(selector[:maxTimeMS]).to be_nil
+        end
+
+        it 'does not include max await time' do
+          expect(selector[:maxAwaitTimeMS]).to be_nil
+        end
+
+        it 'does not include batch size' do
+          expect(selector[:batchSize]).to be_nil
+        end
+      end
+
+      context 'when the cursor is tailable' do
+
+        context 'when await data is true' do
+
+          let(:view) do
+            Mongo::Collection::View.new(
+              authorized_collection,
+              {},
+              await_data: true,
+              tailable: true,
+              max_await_time_ms: 100
+            )
+          end
+
+          it_behaves_like 'a getmore command builder'
+
+          it 'includes max time' do
+            expect(selector[:maxTimeMS]).to eq(100)
+          end
+
+          it 'does not include max await time' do
+            expect(selector[:maxAwaitTimeMS]).to be_nil
+          end
+
+          it 'does not include batch size' do
+            expect(selector[:batchSize]).to be_nil
+          end
+        end
+
+        context 'when await data is false' do
+
+          let(:view) do
+            Mongo::Collection::View.new(
+              authorized_collection,
+              {},
+              tailable: true,
+              max_await_time_ms: 100
+            )
+          end
+
+          it_behaves_like 'a getmore command builder'
+
+          it 'does not include max time' do
+            expect(selector[:maxTimeMS]).to be_nil
+          end
+
+          it 'does not include max await time' do
+            expect(selector[:maxAwaitTimeMS]).to be_nil
+          end
+
+          it 'does not include batch size' do
+            expect(selector[:batchSize]).to be_nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Mongo::Cursor::Builder::OpGetMore do
+
+  describe '#specification' do
+
+    let(:reply) do
+      Mongo::Protocol::Reply.allocate
+    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
+
+    let(:specification) do
+      builder.specification
+    end
+
+    it 'includes to return' do
+      expect(specification[:to_return]).to eq(0)
+    end
+
+    it 'includes the cursor id' do
+      expect(specification[:cursor_id]).to eq(cursor.id)
+    end
+
+    it 'includes the database name' do
+      expect(specification[:db_name]).to eq(TEST_DB)
+    end
+
+    it 'includes the collection name' do
+      expect(specification[:coll_name]).to eq(TEST_COLL)
+    end
+  end
+end

data/spec/mongo/cursor_spec.rb

@@ -4,12 +4,16 @@ describe Mongo::Cursor do
 
   describe '#each' do
 
+    let(:server) do
+      view.read.select_server(authorized_client.cluster)
+    end
+
     let(:reply) do
-      Mongo::Operation::Read::Query.new(query_spec).execute(authorized_primary.context)
+      view.send(:send_initial_query, server)
     end
 
     let(:cursor) do
-      described_class.new(view, reply, authorized_primary)
+      described_class.new(view, reply, server)
     end
 
     context 'when no options are provided to the view' do
@@ -18,10 +22,6 @@ describe Mongo::Cursor do
         Mongo::Collection::View.new(authorized_collection)
       end
 
-      let(:query_spec) do
-        { :selector => {}, :options => {}, :db_name => TEST_DB, :coll_name => TEST_COLL }
-      end
-
       context 'when the initial query retieves all documents' do
 
         let(:documents) do
@@ -97,15 +97,6 @@ describe Mongo::Cursor do
               Mongo::Collection::View.new(authorized_collection, {}, :limit => 2)
             end
 
-            let(:query_spec) do
-              {
-                :selector => {},
-                :options => { :limit => 2 },
-                :db_name => TEST_DB,
-                :coll_name => TEST_COLL
-              }
-            end
-
             it 'returns the correct amount' do
               expect(cursor.to_a.count).to eq(2)
             end
@@ -123,17 +114,12 @@ describe Mongo::Cursor do
               Mongo::Collection::View.new(authorized_collection, {}, :limit => -2)
             end
 
-            let(:query_spec) do
-              {
-                :selector => {},
-                :options => { :limit => -2 },
-                :db_name => TEST_DB,
-                :coll_name => TEST_COLL
-              }
+            it 'returns the positive number of documents', unless: find_command_enabled? do
+              expect(cursor.to_a.count).to eq(2)
             end
 
-            it 'returns the positive number of documents' do
-              expect(cursor.to_a.count).to eq(2)
+            it 'returns all documents', if: find_command_enabled? do
+              expect(cursor.to_a.count).to eq(10)
             end
 
             it 'iterates the documents' do
@@ -149,15 +135,6 @@ describe Mongo::Cursor do
               Mongo::Collection::View.new(authorized_collection, {}, :limit => 0)
             end
 
-            let(:query_spec) do
-              {
-                :selector => {},
-                :options => { :limit => 0 },
-                :db_name => TEST_DB,
-                :coll_name => TEST_COLL
-              }
-            end
-
             it 'returns all documents' do
               expect(cursor.to_a.count).to eq(10)
             end
@@ -182,15 +159,6 @@ describe Mongo::Cursor do
               )
             end
 
-            let(:query_spec) do
-              {
-                :selector => {},
-                :options => { :limit => 5, :batch_size => 3 },
-                :db_name => TEST_DB,
-                :coll_name => TEST_COLL
-              }
-            end
-
             it 'returns the limited number of documents' do
               expect(cursor.to_a.count).to eq(5)
             end
@@ -212,15 +180,6 @@ describe Mongo::Cursor do
               )
             end
 
-            let(:query_spec) do
-              {
-                :selector => {},
-                :options => { :limit => 5, :batch_size => 7 },
-                :db_name => TEST_DB,
-                :coll_name => TEST_COLL
-              }
-            end
-
             it 'returns the limited number of documents' do
               expect(cursor.to_a.count).to eq(5)
             end
@@ -242,15 +201,6 @@ describe Mongo::Cursor do
               )
             end
 
-            let(:query_spec) do
-              {
-                :selector => {},
-                :options => { :limit => 5, :batch_size => 5 },
-                :db_name => TEST_DB,
-                :coll_name => TEST_COLL
-              }
-            end
-
             it 'returns the limited number of documents' do
               expect(cursor.to_a.count).to eq(5)
             end

data/spec/mongo/database_spec.rb

@@ -93,6 +93,26 @@ describe Mongo::Database do
         expect(database.collection_names(batch_size: 1).to_a).to include('users')
       end
     end
+
+    context 'when there are more collections than the initial batch size' do
+
+      before do
+        2.times do |i|
+          database["#{i}_dalmatians"].create
+        end
+      end
+
+      after do
+        2.times do |i|
+          database["#{i}_dalmatians"].drop
+        end
+      end
+
+      it 'returns all collections' do
+        expect(database.collection_names(batch_size: 1).select { |c| c =~ /dalmatians/}.size).to eq(2)
+      end
+
+    end
   end
 
   describe '#list_collections' do
@@ -160,7 +180,7 @@ describe Mongo::Database do
       end
     end
 
-    context 'when the user is not authorized', unless: sharded? do
+    context 'when the user is not authorized', if: auth_enabled? do
 
       let(:database) do
         described_class.new(unauthorized_client, TEST_DB)
@@ -184,6 +204,27 @@ describe Mongo::Database do
       expect(database.command(:ismaster => 1).written_count).to eq(0)
     end
 
+    context 'when a read concern is provided', if: find_command_enabled? do
+
+      context 'when the read concern is valid' do
+
+        it 'sends the read concern' do
+          expect {
+            database.command(:ismaster => 1, readConcern: { level: 'local' })
+          }.to_not raise_error
+        end
+      end
+
+      context 'when the read concern is not valid' do
+
+        it 'raises an exception', if: (find_command_enabled? && !sharded?) do
+          expect {
+            database.command(:ismaster => 1, readConcern: { level: 'yay' })
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+    end
+
     context 'when an alternate read preference is specified' do
 
       before do
@@ -195,7 +236,7 @@ describe Mongo::Database do
       end
 
       let(:client) do
-        authorized_client.with(server_selection_timeout: 2)
+        authorized_client.with(server_selection_timeout: 0.1)
       end
 
       let(:database) do
@@ -208,6 +249,18 @@ describe Mongo::Database do
         end.to raise_error(Mongo::Error::NoServerAvailable)
       end
     end
+
+    context 'when there is a read preference set on the client' do
+
+      let(:database) do
+        described_class.new(authorized_client.with(read: { mode: :secondary }), TEST_DB)
+      end
+
+      it 'does not use the read preference' do
+        expect(database.client.cluster).to receive(:next_primary).and_call_original
+        database.command(ping: 1)
+      end
+    end
   end
 
   describe '#drop' do
@@ -278,7 +331,7 @@ describe Mongo::Database do
     shared_context 'a GridFS database' do
 
       it 'returns a Grid::FS for the db' do
-        expect(fs).to be_a(Mongo::Grid::FS)
+        expect(fs).to be_a(Mongo::Grid::FSBucket)
       end
 
       context 'when operating on the fs' do
@@ -292,8 +345,8 @@ describe Mongo::Database do
         end
 
         after do
-          fs.files_collection.find.delete_many
-          fs.chunks_collection.find.delete_many
+          fs.files_collection.delete_many
+          fs.chunks_collection.delete_many
         end
 
         let(:from_db) do
@@ -301,7 +354,7 @@ describe Mongo::Database do
         end
 
         it 'returns the assembled file from the db' do
-          expect(from_db.filename).to eq(file.metadata.filename)
+          expect(from_db.filename).to eq(file.info.filename)
         end
       end
     end
@@ -317,15 +370,31 @@ describe Mongo::Database do
 
     context 'when a custom prefix is provided' do
 
-      let(:fs) do
-        database.fs(:fs_name => 'grid')
-      end
+      context 'when the option is fs_name' do
 
-      it 'sets the custom prefix' do
-        expect(fs.prefix).to eq('grid')
+        let(:fs) do
+          database.fs(:fs_name => 'grid')
+        end
+
+        it 'sets the custom prefix' do
+          expect(fs.prefix).to eq('grid')
+        end
+
+        it_behaves_like 'a GridFS database'
       end
 
-      it_behaves_like 'a GridFS database'
+      context 'when the option is bucket_name' do
+
+        let(:fs) do
+          database.fs(:bucket_name => 'grid')
+        end
+
+        it 'sets the custom prefix' do
+          expect(fs.prefix).to eq('grid')
+        end
+
+        it_behaves_like 'a GridFS database'
+      end
     end
   end
 end

data/spec/mongo/dbref_spec.rb

@@ -69,7 +69,7 @@ describe Mongo::DBRef do
     end
 
     it 'converts the underlying document to bson' do
-      expect(dbref.to_bson).to eq(dbref.as_json.to_bson)
+      expect(dbref.to_bson.to_s).to eq(dbref.as_json.to_bson.to_s)
     end
   end
 
@@ -100,12 +100,12 @@ describe Mongo::DBRef do
 
   describe '#from_bson' do
 
-    let(:bson) do
-      StringIO.new(dbref.to_bson)
+    let(:buffer) do
+      dbref.to_bson
     end
 
     let(:decoded) do
-      BSON::Document.from_bson(bson)
+      BSON::Document.from_bson(BSON::ByteBuffer.new(buffer.to_s))
     end
 
     context 'when a database exists' do