mongo 2.5.0.beta → 2.5.0

data/spec/mongo/change_stream_examples_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe 'change streams examples in Ruby', if: test_change_streams? do
+
+  let!(:inventory) do
+    client[:inventory]
+  end
+
+  let(:client) do
+    authorized_client.with(max_pool_size: 5, wait_queue_timeout: 3)
+  end
+
+  before do
+    inventory.drop
+  end
+
+  after do
+    client.close
+    inventory.drop
+  end
+
+  context 'example 1 - basic watching'do
+
+    it 'returns a change after an insertion' do
+
+      insert_thread = Thread.new do
+        sleep 2
+        inventory.insert_one(x: 1)
+      end
+
+      stream_thread = Thread.new do
+
+        # Start Changestream Example 1
+
+        cursor = inventory.watch.to_enum
+        next_change = cursor.next
+
+        # End Changestream Example 1
+      end
+
+      insert_thread.value
+      change = stream_thread.value
+
+      expect(change['_id']).not_to be_nil
+      expect(change['_id']['_data']).not_to be_nil
+      expect(change['operationType']).to eq('insert')
+      expect(change['fullDocument']).not_to be_nil
+      expect(change['fullDocument']['_id']).not_to be_nil
+      expect(change['fullDocument']['x']).to eq(1)
+      expect(change['ns']).not_to be_nil
+      expect(change['ns']['db']).to eq(TEST_DB)
+      expect(change['ns']['coll']).to eq(inventory.name)
+      expect(change['documentKey']).not_to be_nil
+      expect(change['documentKey']['_id']).to eq(change['fullDocument']['_id'])
+    end
+  end
+
+  context 'example 2 - full document update lookup specified' do
+
+    it 'returns a change and the delta after an insertion' do
+
+      inventory.insert_one(_id: 1, x: 2)
+
+      update_thread = Thread.new do
+        sleep 2
+        inventory.update_one({ _id: 1}, { '$set' => { x: 5 }})
+      end
+
+      stream_thread = Thread.new do
+
+        # Start Changestream Example 2
+
+        cursor = inventory.watch([], full_document: 'updateLookup').to_enum
+        next_change = cursor.next
+
+        # End Changestream Example 2
+      end
+
+
+      update_thread.value
+      change = stream_thread.value
+
+      expect(change['_id']).not_to be_nil
+      expect(change['_id']['_data']).not_to be_nil
+      expect(change['operationType']).to eq('update')
+      expect(change['fullDocument']).not_to be_nil
+      expect(change['fullDocument']['_id']).to eq(1)
+      expect(change['fullDocument']['x']).to eq(5)
+      expect(change['ns']).not_to be_nil
+      expect(change['ns']['db']).to eq(TEST_DB)
+      expect(change['ns']['coll']).to eq(inventory.name)
+      expect(change['documentKey']).not_to be_nil
+      expect(change['documentKey']['_id']).to eq(1)
+      expect(change['updateDescription']).not_to be_nil
+      expect(change['updateDescription']['updatedFields']).not_to be_nil
+      expect(change['updateDescription']['updatedFields']['x']).to eq(5)
+      expect(change['updateDescription']['removedFields']).to eq([])
+    end
+  end
+
+  context 'example 3 - resuming from a previous change' do
+
+    it 'returns the correct change when resuming' do
+
+      stream = inventory.watch
+      cursor = stream.to_enum
+      inventory.insert_one(x: 1)
+      next_change = cursor.next
+
+      expect(next_change['_id']).not_to be_nil
+      expect(next_change['_id']['_data']).not_to be_nil
+      expect(next_change['operationType']).to eq('insert')
+      expect(next_change['fullDocument']).not_to be_nil
+      expect(next_change['fullDocument']['_id']).not_to be_nil
+      expect(next_change['fullDocument']['x']).to eq(1)
+      expect(next_change['ns']).not_to be_nil
+      expect(next_change['ns']['db']).to eq(TEST_DB)
+      expect(next_change['ns']['coll']).to eq(inventory.name)
+      expect(next_change['documentKey']).not_to be_nil
+      expect(next_change['documentKey']['_id']).to eq(next_change['fullDocument']['_id'])
+
+      inventory.insert_one(x: 2)
+      next_next_change = cursor.next
+      stream.close
+
+      expect(next_next_change['_id']).not_to be_nil
+      expect(next_next_change['_id']['_data']).not_to be_nil
+      expect(next_next_change['operationType']).to eq('insert')
+      expect(next_next_change['fullDocument']).not_to be_nil
+      expect(next_next_change['fullDocument']['_id']).not_to be_nil
+      expect(next_next_change['fullDocument']['x']).to eq(2)
+      expect(next_next_change['ns']).not_to be_nil
+      expect(next_next_change['ns']['db']).to eq(TEST_DB)
+      expect(next_next_change['ns']['coll']).to eq(inventory.name)
+      expect(next_next_change['documentKey']).not_to be_nil
+      expect(next_next_change['documentKey']['_id']).to eq(next_next_change['fullDocument']['_id'])
+
+      # Start Changestream Example 3
+
+      resume_token = next_change['_id']
+      cursor = inventory.watch([], resume_after: resume_token).to_enum
+      resumed_change = cursor.next
+
+      # End Changestream Example 3
+
+      expect(resumed_change.length).to eq(next_next_change.length)
+      resumed_change.each { |key| expect(resumed_change[key]).to eq(next_next_change[key]) }
+    end
+  end
+end

data/spec/mongo/client_spec.rb

@@ -218,6 +218,21 @@ describe Mongo::Client do
 
     context 'when providing options' do
 
+      context 'when retry_writes is defined' do
+
+        let(:options) do
+          { retry_writes: true }
+        end
+
+        let(:client) do
+          described_class.new([default_address.seed], authorized_client.options.merge(options))
+        end
+
+        it 'sets the option' do
+          expect(client.options['retry_writes']).to eq(options[:retry_writes])
+        end
+      end
+
       context 'when compressors are provided' do
 
         let(:client) do
@@ -617,6 +632,21 @@ describe Mongo::Client do
 
     context 'when providing a connection string' do
 
+      context 'when the string uses the SRV Protocol' do
+
+        let!(:uri) do
+          'mongodb+srv://test5.test.build.10gen.cc/testdb'
+        end
+
+        let(:client) do
+          described_class.new(uri)
+        end
+
+        it 'sets the database' do
+          expect(client.options[:database]).to eq('testdb')
+        end
+      end
+
       context 'when a database is provided' do
 
         let!(:uri) do
@@ -1276,6 +1306,22 @@ describe Mongo::Client do
         'admin'
       )
     end
+
+    context 'when filter criteria is present', if: sessions_enabled? do
+
+      let(:result) do
+        root_authorized_client.database_names(filter)
+      end
+
+      let(:filter) do
+        { name: TEST_DB }
+      end
+
+      it 'returns a filtered list of database names' do
+        expect(result.length).to eq(1)
+        expect(result.first).to eq(filter[:name])
+      end
+    end
   end
 
   describe '#list_databases' do
@@ -1286,9 +1332,94 @@ describe Mongo::Client do
           i['name']
         end).to include('admin')
     end
+
+    context 'when filter criteria is present', if: sessions_enabled? do
+
+      let(:result) do
+        root_authorized_client.list_databases(filter)
+      end
+
+      let(:filter) do
+        { name: TEST_DB }
+      end
+
+      it 'returns a filtered list of database info documents' do
+        expect(result.length).to eq(1)
+        expect(result[0]['name']).to eq(filter[:name])
+      end
+    end
+
+    context 'when name_only is true' do
+
+      let(:client_options) do
+        root_authorized_client.options.merge(heartbeat_frequency: 100, monitoring: true)
+      end
+
+      let(:client) do
+        # Monitoring subscribers won't be set up when using Client#with, so a new client must be created.
+        Mongo::Client.new(ADDRESSES, client_options).tap do |cl|
+          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        end
+      end
+
+      let(:subscriber) do
+        EventSubscriber.new
+      end
+
+      let(:command) do
+        subscriber.started_events.find { |c| c.command_name == :listDatabases }.command
+      end
+
+      before do
+        client.list_databases({}, true)
+      end
+
+      it 'sends the command with the nameOnly flag set to true' do
+        expect(command[:nameOnly]).to be(true)
+      end
+    end
+  end
+
+  describe '#list_mongo_databases' do
+
+    let(:options) do
+      { read: { mode: :secondary } }
+    end
+
+    let(:client) do
+      root_authorized_client.with(options)
+    end
+
+    let(:result) do
+      client.list_mongo_databases
+    end
+
+    it 'returns a list of Mongo::Database objects' do
+      expect(result).to all(be_a(Mongo::Database))
+    end
+
+    it 'creates database with specified options' do
+      expect(result.first.options[:read]).to eq(BSON::Document.new(options)[:read])
+    end
+
+    context 'when filter criteria is present', if: sessions_enabled? do
+
+      let(:result) do
+        client.list_mongo_databases(filter)
+      end
+
+      let(:filter) do
+        { name: TEST_DB }
+      end
+
+      it 'returns a filtered list of Mongo::Database objects' do
+        expect(result.length).to eq(1)
+        expect(result.first.name).to eq(filter[:name])
+      end
+    end
   end
 
-    describe '#close' do
+  describe '#close' do
 
     let(:client) do
       described_class.new(['127.0.0.1:27017'])
@@ -1359,7 +1490,7 @@ describe Mongo::Client do
       authorized_client.start_session
     end
 
-    context 'when sessions are supported', if: sessions_enabled? do
+    context 'when sessions are supported', if: test_sessions? do
 
       it 'creates a session' do
         expect(session).to be_a(Mongo::Session)
@@ -1410,6 +1541,10 @@ describe Mongo::Client do
         end
 
         before do
+          session_a_server_session.next_txn_num
+          session_a_server_session.next_txn_num
+          session_b_server_session.next_txn_num
+          session_b_server_session.next_txn_num
           session_a.end_session
           session_b.end_session
         end
@@ -1418,6 +1553,11 @@ describe Mongo::Client do
           expect(authorized_client.start_session.instance_variable_get(:@server_session)).to be(session_b_server_session)
           expect(authorized_client.start_session.instance_variable_get(:@server_session)).to be(session_a_server_session)
         end
+
+        it 'preserves the transaction numbers on the server sessions' do
+          expect(authorized_client.start_session.next_txn_num).to be(2)
+          expect(authorized_client.start_session.next_txn_num).to be(2)
+        end
       end
 
       context 'when an implicit session is used' do

data/spec/mongo/cluster/cursor_reaper_spec.rb

@@ -25,47 +25,6 @@ describe Mongo::Cluster::CursorReaper do
     end
   end
 
-  describe '#run' do
-
-    it 'starts a thread calling #kill_cursors' do
-      reaper.run!
-      expect(reaper.instance_variable_get(:@thread)).to be_a(Thread)
-    end
-
-    context 'when run is called more than once' do
-
-      let!(:reaper_thread) do
-        reaper.run!
-        reaper.instance_variable_get(:@reaper)
-      end
-
-      it 'only starts a thread once' do
-        reaper.run!
-        expect(reaper.instance_variable_get(:@reaper)).to be(reaper_thread)
-      end
-    end
-
-    context 'when there are ops in the list to execute' do
-
-      let(:server) { double('server') }
-      let(:cursor_id) { 1 }
-      let(:op_spec_1) { double('op_spec_1') }
-      let(:op_spec_2) { double('op_spec_2') }
-      let(:to_kill) { reaper.instance_variable_get(:@to_kill)}
-
-      before do
-        reaper.register_cursor(cursor_id)
-        reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
-        reaper.run!
-        sleep(Mongo::Cluster::CursorReaper::FREQUENCY + 1)
-      end
-
-      it 'executes the ops in the thread' do
-        expect(reaper.instance_variable_get(:@to_kill).size).to eq(0)
-      end
-    end
-  end
-
   describe '#schedule_kill_cursor' do
 
     let(:server) { double('server') }
@@ -184,33 +143,4 @@ describe Mongo::Cluster::CursorReaper do
       end
     end
   end
-
-  describe '#stop!' do
-
-    let(:thread) do
-      reaper.run!
-      reaper.stop!
-      sleep(0.5)
-      reaper.instance_variable_get(:@thread)
-    end
-
-    it 'stops the thread from running' do
-      expect(thread.alive?).to be(false)
-    end
-  end
-
-  describe '#restart!' do
-
-    let(:thread) do
-      reaper.run!
-      reaper.stop!
-      sleep(0.5)
-      reaper.restart!
-      reaper.instance_variable_get(:@thread)
-    end
-
-    it 'restarts the thread' do
-      expect(thread.alive?).to be(true)
-    end
-  end
 end

data/spec/mongo/cluster/socket_reaper_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Mongo::Cluster::SocketReaper do
+
+  let(:cluster) do
+    authorized_client.cluster
+  end
+
+  let(:reaper) do
+    described_class.new(cluster)
+  end
+
+  describe '#initialize' do
+
+    it 'takes a cluster as an argument' do
+      expect(reaper).to be_a(described_class)
+    end
+  end
+
+  describe '#execute' do
+
+    before do
+      cluster.servers.each do |s|
+        expect(s.pool).to receive(:close_stale_sockets!).and_call_original
+      end
+    end
+
+    it 'calls close_stale_sockets on each connection pool in the cluster' do
+      reaper.execute
+    end
+  end
+end