mongo 2.9.2 → 2.10.0.rc0

data/spec/mongo/cursor_spec.rb

@@ -28,17 +28,27 @@ describe Mongo::Cursor do
     end
 
     context 'cursor exhausted by initial result' do
+      before do
+        ClientRegistry.instance.close_all_clients
+      end
+
       let(:view) do
         Mongo::Collection::View.new(authorized_collection)
       end
 
       it 'does not schedule the finalizer' do
-        expect(ObjectSpace).not_to receive(:define_finalizer)
-        cursor
+        # Due to https://jira.mongodb.org/browse/RUBY-1772, restrict
+        # the scope of the assertion
+        RSpec::Mocks.with_temporary_scope do
+          expect(ObjectSpace).not_to receive(:define_finalizer)
+          cursor
+        end
       end
     end
 
     context 'cursor not exhausted by initial result' do
+      clean_slate
+
       let(:view) do
         Mongo::Collection::View.new(authorized_collection, {}, batch_size: 2)
       end
@@ -273,7 +283,7 @@ describe Mongo::Cursor do
     context 'when the cursor is not fully iterated and is garbage collected' do
 
       let(:documents) do
-        (1..3).map{ |i| { field: "test#{i}" }}
+        (1..6).map{ |i| { field: "test#{i}" }}
       end
 
       let(:cluster) do
@@ -304,14 +314,42 @@ describe Mongo::Cursor do
         cluster.instance_variable_get(:@periodic_executor).flush
         expect {
           cursor.to_a
-        }.to raise_exception(Mongo::Error::OperationFailure)
+        }.to raise_exception(Mongo::Error::OperationFailure, /[cC]ursor.*not found/)
       end
 
       context 'when the cursor is unregistered before the kill cursors operations are executed' do
 
         it 'does not send a kill cursors operation for the unregistered cursor' do
+          # We need to verify that the cursor was able to retrieve more documents
+          # from the server so that more than one batch is successfully received
+
           cluster.unregister_cursor(cursor.id)
-          expect(cursor.to_a.size).to eq(documents.size)
+
+          # The initial read is done on an enum obtained from the cursor.
+          # The read below is done directly on the cursor. These are two
+          # different objects. In MRI, iterating like this yields all of the
+          # documents, hence we retrieved one document in the setup and
+          # we expect to retrieve the remaining 5 here. In JRuby it appears that
+          # the enum may buffers the first batch, such that the second document
+          # sometimes is lost to the iteration and we retrieve 4 documents below.
+          # But sometimes we get all 5 documents. In either case, all of the
+          # documents are retrieved via two batches thus fulfilling the
+          # requirement of the test to continue iterating the cursor.
+
+=begin When repeated iteration of cursors is prohibited, these are the expectations
+          if BSON::Environment.jruby?
+            expected_counts = [4, 5]
+          else
+            expected_counts = [5]
+          end
+=end
+
+          # Since currently repeated iteration of cursors is allowed, calling
+          # to_a on the cursor would perform such an iteration and return
+          # all documents of the initial read.
+          expected_counts = [6]
+
+          expect(expected_counts).to include(cursor.to_a.size)
         end
       end
     end
@@ -460,4 +498,78 @@ describe Mongo::Cursor do
       expect(cursor.inspect).to match(/.*#{view.inspect}.*/)
     end
   end
+
+  describe '#to_a' do
+
+    let(:view) do
+      Mongo::Collection::View.new(authorized_collection, {}, batch_size: 10)
+    end
+
+    let(:query_spec) do
+      { :selector => {}, :options => {}, :db_name => SpecConfig.instance.test_db,
+        :coll_name => authorized_collection.name }
+    end
+
+    let(:reply) do
+      view.send(:send_initial_query, authorized_primary)
+    end
+
+    let(:cursor) do
+      described_class.new(view, reply, authorized_primary)
+    end
+
+    context 'after partially iterating the cursor' do
+      before do
+        authorized_collection.drop
+        docs = []
+        100.times do |i|
+          docs << {a: i}
+        end
+        authorized_collection.insert_many(docs)
+      end
+
+      context 'after #each was called once' do
+        before do
+          cursor.each do |doc|
+            break
+          end
+        end
+
+        it 'iterates from the beginning of the view' do
+          expect(cursor.to_a.map { |doc| doc['a'] }).to eq((0..99).to_a)
+        end
+      end
+
+      context 'after exactly one batch was iterated' do
+        before do
+          cursor.each_with_index do |doc, i|
+            break if i == 9
+          end
+        end
+
+        it 'iterates from the beginning of the view' do
+          expect(cursor.to_a.map { |doc| doc['a'] }).to eq((0..99).to_a)
+        end
+      end
+
+      context 'after two batches were iterated' do
+        before do
+          cursor.each_with_index do |doc, i|
+            break if i == 19
+          end
+        end
+
+=begin Behavior of pre-2.10 driver:
+        it 'skips the second batch' do
+          expect(cursor.to_a.map { |doc| doc['a'] }).to eq((0..9).to_a + (20..99).to_a)
+        end
+=end
+        it 'raises NotImplementedError' do
+          expect do
+            cursor.to_a
+          end.to raise_error(NotImplementedError, 'Cannot restart iteration of a cursor which issued a getMore')
+        end
+      end
+    end
+  end
 end

data/spec/mongo/database_spec.rb

@@ -96,12 +96,25 @@ describe Mongo::Database do
       database[:users].create
     end
 
+    let(:actual) do
+      database.collection_names
+    end
+
     it 'returns the stripped names of the collections' do
-      expect(database.collection_names).to include('users')
+      expect(actual).to include('users')
     end
 
     it 'does not include system collections' do
-      expect(database.collection_names).to_not include('system.indexes')
+      expect(actual).to_not include('version')
+      expect(actual).to_not include('system.version')
+    end
+
+    context 'on 2.6 server' do
+      max_server_version '2.6'
+    end
+
+    it 'does not include collections with $ in names' do
+      expect(actual.none? { |name| name.include?('$') }).to be true
     end
 
     context 'when provided a session' do
@@ -136,7 +149,9 @@ describe Mongo::Database do
       end
 
       it 'returns all collections' do
-        expect(database.collection_names(batch_size: 1).select { |c| c =~ /dalmatians/}.size).to eq(2)
+        collection_names = database.collection_names(batch_size: 1)
+        expect(collection_names).to include('0_dalmatians')
+        expect(collection_names).to include('1_dalmatians')
       end
 
     end
@@ -155,15 +170,15 @@ describe Mongo::Database do
     end
 
     before do
-      database[:users].drop
-      database[:users].create
+      database[:acol].drop
+      database[:acol].create
     end
 
     context 'server 3.0+' do
       min_server_fcv '3.0'
 
       it 'returns a list of the collections info' do
-        expect(result).to include('users')
+        expect(result).to include('acol')
       end
     end
 
@@ -171,7 +186,37 @@ describe Mongo::Database do
       max_server_fcv '2.6'
 
       it 'returns a list of the collections info' do
-        expect(result).to include("#{SpecConfig.instance.test_db}.users")
+        expect(result).to include("#{SpecConfig.instance.test_db}.acol")
+      end
+    end
+
+    it 'does not include collections with $ in names' do
+      expect(result.none? { |name| name.include?('$') }).to be true
+    end
+
+    context 'on admin database' do
+      let(:database) do
+        described_class.new(root_authorized_client, 'admin')
+      end
+
+      it 'does not include system collections' do
+        expect(result.none? { |name| name =~ /(^|\.)system\./ }).to be true
+      end
+
+      context 'server 3.0+' do
+        min_server_fcv '3.0'
+
+        it 'returns results' do
+          expect(result).to include('acol')
+        end
+      end
+
+      context 'server 2.6-' do
+        max_server_version '2.6'
+
+        it 'returns results' do
+          expect(result).to include('admin.acol')
+        end
       end
     end
   end
@@ -197,8 +242,21 @@ describe Mongo::Database do
         expect(database.collections).to include(collection)
       end
 
+      it 'does not include collections with $ in names' do
+        expect(database.collections.none? { |c| c.name.include?('$') }).to be true
+      end
+    end
+
+    context 'on admin database' do
+
+      let(:database) do
+        described_class.new(root_authorized_client, 'admin')
+      end
+
       it 'does not include the system collections' do
-        expect(database.collections.collect(&:name).none? { |name| name =~ /system\.|\$/ }).to be(true)
+        collection_names = database.collections.map(&:name)
+        expect(collection_names).not_to include('system.version')
+        expect(collection_names.none? { |name| name =~ /(^|\.)system\./ }).to be true
       end
     end
 
@@ -631,4 +689,178 @@ describe Mongo::Database do
       end
     end
   end
+
+  describe '#write_concern' do
+
+    let(:client) do
+      new_local_client(['127.0.0.1:27017'],
+        {monitoring_io: false}.merge(client_options))
+    end
+
+    let(:database) { client.database }
+
+    context 'when client write concern uses :write' do
+
+      let(:client_options) do
+        { :write => { :w => 1 } }
+      end
+
+      it 'is the correct write concern' do
+        expect(database.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
+        expect(database.write_concern.options).to eq(w: 1)
+      end
+    end
+
+    context 'when client write concern uses :write_concern' do
+
+      let(:client_options) do
+        { :write_concern => { :w => 1 } }
+      end
+
+      it 'is the correct write concern' do
+        expect(database.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
+        expect(database.write_concern.options).to eq(w: 1)
+      end
+    end
+  end
+
+  describe '#aggregate' do
+    min_server_fcv '3.6'
+
+    let(:client) do
+      root_authorized_admin_client
+    end
+
+    let(:database) { client.database }
+
+    let(:pipeline) do
+      [{'$currentOp' => {}}]
+    end
+
+    describe 'updating cluster time' do
+      # The shared examples use their own client which we cannot override
+      # from here, and it uses the wrong credentials for admin database which
+      # is the one we need for our pipeline when auth is on.
+      require_no_auth
+
+      let(:database_via_client) do
+        client.use(:admin).database
+      end
+
+      let(:operation) do
+        database_via_client.aggregate(pipeline).first
+      end
+
+      let(:operation_with_session) do
+        database_via_client.aggregate(pipeline, session: session).first
+      end
+
+      let(:second_operation) do
+        database_via_client.aggregate(pipeline, session: session).first
+      end
+
+      it_behaves_like 'an operation updating cluster time'
+    end
+
+    it 'returns an Aggregation object' do
+      expect(database.aggregate(pipeline)).to be_a(Mongo::Collection::View::Aggregation)
+    end
+
+    context 'when options are provided' do
+
+      let(:options) do
+        { :allow_disk_use => true, :bypass_document_validation => true }
+      end
+
+      it 'sets the options on the Aggregation object' do
+        expect(database.aggregate(pipeline, options).options).to eq(BSON::Document.new(options))
+      end
+
+      context 'when the :comment option is provided' do
+
+        let(:options) do
+          { :comment => 'testing' }
+        end
+
+        it 'sets the options on the Aggregation object' do
+          expect(database.aggregate(pipeline, options).options).to eq(BSON::Document.new(options))
+        end
+      end
+
+      context 'when a session is provided' do
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:operation) do
+          database.aggregate(pipeline, session: session).to_a
+        end
+
+        let(:failed_operation) do
+          database.aggregate([ { '$invalid' => 1 }], session: session).to_a
+        end
+
+        it_behaves_like 'an operation using a session'
+        it_behaves_like 'a failed operation using a session'
+      end
+
+      context 'when a hint is provided' do
+
+        let(:options) do
+          { 'hint' => { 'y' => 1 } }
+        end
+
+        it 'sets the options on the Aggregation object' do
+          expect(database.aggregate(pipeline, options).options).to eq(options)
+        end
+      end
+
+      context 'when collation is provided' do
+
+        let(:pipeline) do
+          [{ "$currentOp" => {} }]
+        end
+
+        let(:options) do
+          { collation: { locale: 'en_US', strength: 2 } }
+        end
+
+        let(:result) do
+          database.aggregate(pipeline, options).collect { |doc| doc.keys.grep(/host/).first }
+        end
+
+        context 'when the server selected supports collations' do
+          min_server_fcv '3.4'
+
+          it 'applies the collation' do
+            expect(result.uniq).to eq(['host'])
+          end
+        end
+
+        context 'when the server selected does not support collations' do
+          max_server_version '3.2'
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+
+          context 'when a String key is used' do
+
+            let(:options) do
+              { 'collation' => { locale: 'en_US', strength: 2 } }
+            end
+
+            it 'raises an exception' do
+              expect {
+                result
+              }.to raise_exception(Mongo::Error::UnsupportedCollation)
+            end
+          end
+        end
+      end
+    end
+  end
 end