mongo 2.1.2 → 2.2.0.rc0

data/spec/mongo/command_monitoring_spec.rb

@@ -1,47 +1,60 @@
 require 'spec_helper'
 
-def runnable?(file)
+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|
 
-    spec = Mongo::CommandMonitoring::Spec.new(file)
+    if !skippable?(file)
 
-    spec.tests.each do |test|
+      spec = Mongo::CommandMonitoring::Spec.new(file)
 
-      context(test.description) do
+      spec.tests.each do |test|
 
-        let(:subscriber) do
-          Mongo::CommandMonitoring::TestSubscriber.new
-        end
+        context(test.description) do
 
-        let(:monitoring) do
-          authorized_client.instance_variable_get(:@monitoring)
-        end
+          let(:subscriber) do
+            Mongo::CommandMonitoring::TestSubscriber.new
+          end
 
-        before do
-          authorized_collection.find.delete_many
-          authorized_client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-        end
+          let(:monitoring) do
+            authorized_client.instance_variable_get(:@monitoring)
+          end
 
-        after do
-          monitoring.subscribers[Mongo::Monitoring::COMMAND].delete(subscriber)
-          authorized_collection.find.delete_many
-        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|
+          test.expectations.each do |expectation|
 
-          it "generates a #{expectation.event_name} for #{expectation.command_name}", unless: runnable?(file) 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)
+            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

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

@@ -97,19 +97,19 @@ describe Mongo::Database do
     context 'when there are more collections than the initial batch size' do
 
       before do
-        200.times do |i|
+        2.times do |i|
           database["#{i}_dalmatians"].create
         end
       end
 
       after do
-        200.times do |i|
+        2.times do |i|
           database["#{i}_dalmatians"].drop
         end
       end
 
       it 'returns all collections' do
-        expect(database.collection_names.select { |c| c =~ /dalmatians/}.size).to eq(200)
+        expect(database.collection_names(batch_size: 1).select { |c| c =~ /dalmatians/}.size).to eq(2)
       end
 
     end
@@ -204,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