mongo 2.5.0.beta → 2.5.0

data/spec/mongo/server/description_spec.rb

@@ -14,7 +14,7 @@ describe Mongo::Server::Description do
       'arbiters' => [
         '127.0.0.1:27120'
       ],
-      'primary' => '127.0.0.1:27019',
+      'primary' => authorized_primary.address.to_s,
       'tags' => { 'rack' => 'a' },
       'me' => '127.0.0.1:27019',
       'maxBsonObjectSize' => 16777216,
@@ -25,12 +25,14 @@ describe Mongo::Server::Description do
       'localTime' => Time.now,
       'lastWrite' => { 'lastWriteDate' => Time.now },
       'logicalSessionTimeoutMinutes' => 7,
+      'operationTime' => 1,
+      '$clusterTime' => 1,
       'ok' => 1
     }
   end
 
   let(:address) do
-    Mongo::Address.new('127.0.0.1:27017')
+    Mongo::Address.new(authorized_primary.address.to_s)
   end
 
   let(:monitoring) do
@@ -868,7 +870,8 @@ describe Mongo::Server::Description do
       described_class.new(address, replica.merge(
         'localTime' => 1,
         'lastWrite' => { 'lastWriteDate' => 1 },
-        'operationTime' => 1
+        'operationTime' => 2,
+        '$clusterTime' => 2
       ))
     end
 

data/spec/mongo/server_spec.rb

@@ -201,4 +201,91 @@ describe Mongo::Server do
       expect(server.reconnect!).to be(true)
     end
   end
+
+  describe 'retry_writes?' do
+
+    let(:server) do
+      described_class.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+    end
+
+    before do
+      allow(server).to receive(:features).and_return(features)
+    end
+
+    context 'when the server version is less than 3.6' do
+
+      let(:features) do
+        double('features', sessions_enabled?: false)
+      end
+
+      context 'when the server has a logical_session_timeout value' do
+
+        before do
+          allow(server).to receive(:logical_session_timeout).and_return(true)
+        end
+
+        it 'returns false' do
+          expect(server.retry_writes?).to be(false)
+        end
+      end
+
+      context 'when the server does not have a logical_session_timeout value' do
+
+        before do
+          allow(server).to receive(:logical_session_timeout).and_return(nil)
+        end
+
+        it 'returns false' do
+          expect(server.retry_writes?).to be(false)
+        end
+      end
+    end
+
+    context 'when the server version is at least 3.6' do
+
+      let(:features) do
+        double('features', sessions_enabled?: true)
+      end
+
+      context 'when the server has a logical_session_timeout value' do
+
+        before do
+          allow(server).to receive(:logical_session_timeout).and_return(true)
+        end
+
+        context 'when the server is a standalone' do
+
+          before do
+            allow(server).to receive(:standalone?).and_return(true)
+          end
+
+          it 'returns false' do
+            expect(server.retry_writes?).to be(false)
+          end
+        end
+
+        context 'when the server is not a standalone' do
+
+          before do
+            allow(server).to receive(:standalone?).and_return(true)
+          end
+
+          it 'returns false' do
+            expect(server.retry_writes?).to be(false)
+          end
+        end
+      end
+
+      context 'when the server does not have a logical_session_timeout value' do
+
+        before do
+          allow(server).to receive(:logical_session_timeout).and_return(nil)
+        end
+
+        it 'returns false' do
+          expect(server.retry_writes?).to be(false)
+        end
+      end
+    end
+  end
 end

data/spec/mongo/session/server_session_spec.rb

@@ -9,8 +9,51 @@ describe Mongo::Session::ServerSession do
     end
 
     it 'sets a UUID as the session id' do
+      expect(described_class.new.instance_variable_get(:@session_id)).to be_a(BSON::Document)
       expect(described_class.new.session_id).to be_a(BSON::Document)
       expect(described_class.new.session_id[:id]).to be_a(BSON::Binary)
     end
   end
+
+  describe '#next_txn_number' do
+
+    it 'advances and returns the next transaction number' do
+      expect(described_class.new.next_txn_num).to be(0)
+    end
+
+    context 'when the method is called multiple times' do
+
+      let(:server_session) do
+        described_class.new
+      end
+
+      before do
+        server_session.next_txn_num
+        server_session.next_txn_num
+      end
+
+      it 'advances and returns the next transaction number' do
+        expect(server_session.next_txn_num).to be(2)
+      end
+    end
+  end
+
+  describe '#inspect' do
+
+    let(:session) do
+      described_class.new
+    end
+
+    it 'includes the Ruby object_id in the formatted string' do
+      expect(session.inspect).to include(session.object_id.to_s)
+    end
+
+    it 'includes the session_id in the formatted string' do
+      expect(session.inspect).to include(session.session_id.to_s)
+    end
+
+    it 'includes the last_use in the formatted string' do
+      expect(session.inspect).to include(session.last_use.to_s)
+    end
+  end
 end

data/spec/mongo/session/session_pool_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mongo::Session::SessionPool do
+describe Mongo::Session::SessionPool, if: test_sessions? do
 
   describe '.create' do
 
@@ -32,7 +32,27 @@ describe Mongo::Session::SessionPool do
     end
   end
 
-  describe 'checkout', if: sessions_enabled? do
+  describe '#inspect' do
+
+    let(:pool) do
+      described_class.new(authorized_client)
+    end
+
+    before do
+      s = pool.checkout
+      pool.checkin(s)
+    end
+
+    it 'includes the Ruby object_id in the formatted string' do
+      expect(pool.inspect).to include(pool.object_id.to_s)
+    end
+
+    it 'includes the pool size in the formatted string' do
+      expect(pool.inspect).to include('current_size=1')
+    end
+  end
+
+  describe 'checkout' do
 
     let(:pool) do
       described_class.new(authorized_client)
@@ -115,7 +135,7 @@ describe Mongo::Session::SessionPool do
     end
   end
 
-  describe '#end_sessions', if: sessions_enabled? do
+  describe '#end_sessions' do
 
     let(:pool) do
       described_class.create(client)
@@ -139,44 +159,60 @@ describe Mongo::Session::SessionPool do
       EventSubscriber.new
     end
 
-    before do
-      client.database.command(ping: 1)
-      pool.checkin(session_a)
-      pool.checkin(session_b)
-      pool.end_sessions
-    end
-
     after do
       client.close
     end
 
-    let(:end_sessions_command) do
-      subscriber.started_events.find { |c| c.command_name == :endSessions}
-    end
+    context 'when the number of ids is not larger than 10,000' do
 
-    it 'sends the endSessions command with all the session ids' do
-      expect(end_sessions_command.command[:ids]).to include(BSON::Document.new(session_a.session_id))
-      expect(end_sessions_command.command[:ids]).to include(BSON::Document.new(session_b.session_id))
-    end
+      before do
+        client.database.command(ping: 1)
+        pool.checkin(session_a)
+        pool.checkin(session_b)
+      end
+
+      let!(:cluster_time) do
+        client.cluster.cluster_time
+      end
 
-    context 'when talking to a mongos', if: sessions_enabled? && sharded? do
+      let(:end_sessions_command) do
+        pool.end_sessions
+        subscriber.started_events.find { |c| c.command_name == :endSessions}
+      end
 
       it 'sends the endSessions command with all the session ids' do
-        expect(end_sessions_command.command[:ids]).to include(BSON::Document.new(session_a.session_id))
-        expect(end_sessions_command.command[:ids]).to include(BSON::Document.new(session_b.session_id))
-        expect(end_sessions_command.command[:$clusterTime]).to eq(client.cluster.cluster_time)
+        end_sessions_command
+        expect(end_sessions_command.command[:endSessions]).to include(BSON::Document.new(session_a.session_id))
+        expect(end_sessions_command.command[:endSessions]).to include(BSON::Document.new(session_b.session_id))
+      end
+
+      context 'when talking to a replica set or mongos' do
+
+        it 'sends the endSessions command with all the session ids and cluster time' do
+          end_sessions_command
+          expect(end_sessions_command.command[:endSessions]).to include(BSON::Document.new(session_a.session_id))
+          expect(end_sessions_command.command[:endSessions]).to include(BSON::Document.new(session_b.session_id))
+          expect(end_sessions_command.command[:$clusterTime]).to eq(client.cluster.cluster_time)
+        end
       end
     end
 
     context 'when the number of ids is larger than 10_000' do
 
+      let(:ids) do
+        10_001.times.map do |i|
+          bytes = [SecureRandom.uuid.gsub(/\-/, '')].pack('H*')
+          BSON::Document.new(id: BSON::Binary.new(bytes, :uuid))
+        end
+      end
+
       before do
         queue = []
-        10_001.times do |i|
-          queue << double('session', session_id: i)
+        ids.each do |id|
+          queue << double('session', session_id: id)
         end
         pool.instance_variable_set(:@queue, queue)
-        expect(Mongo::Operation::Commands::Command).to receive(:new).at_least(:twice)
+        expect(Mongo::Operation::Commands::Command).to receive(:new).at_least(:twice).and_call_original
       end
 
       let(:end_sessions_commands) do
@@ -185,9 +221,9 @@ describe Mongo::Session::SessionPool do
 
       it 'sends the command more than once' do
         pool.end_sessions
-        # expect(end_sessions_commands.size).to eq(2)
-        # expect(end_sessions_commands[0].command[:ids]).to eq([*0...10_000])
-        # expect(end_sessions_commands[1].command[:ids]).to eq([10_000])
+        expect(end_sessions_commands.size).to eq(2)
+        expect(end_sessions_commands[0].command[:endSessions]).to eq(ids[0...10_000])
+        expect(end_sessions_commands[1].command[:endSessions]).to eq([ids[10_000]])
       end
     end
   end

data/spec/mongo/session_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+
+describe Mongo::Session, if: test_sessions? do
+
+  let(:session) do
+    authorized_client.start_session(options)
+  end
+
+  let(:options) do
+    {}
+  end
+
+  describe '#initialize' do
+
+    context 'when options are provided' do
+
+      it 'duplicates and freezes the options' do
+        expect(session.options).not_to be(options)
+        expect(session.options.frozen?).to be(true)
+      end
+    end
+
+    it 'sets a server session with an id' do
+      expect(session.session_id).to be_a(BSON::Document)
+    end
+
+    it 'sets the cluster time to nil' do
+      expect(session.cluster_time).to be(nil)
+    end
+
+    it 'sets the client' do
+      expect(session.client).to be(authorized_client)
+    end
+  end
+
+  describe '#inspect' do
+
+    it 'includes the Ruby object_id in the formatted string' do
+      expect(session.inspect).to include(session.object_id.to_s)
+    end
+
+    it 'includes the session_id in the formatted string' do
+      expect(session.inspect).to include(session.session_id.to_s)
+    end
+
+    context 'when options are provided' do
+
+      let(:options) do
+        { causal_consistency: true }
+      end
+
+      it 'includes the options in the formatted string' do
+        expect(session.inspect).to include({ causal_consistency: true }.to_s)
+      end
+    end
+  end
+
+  describe '#advance_cluster_time' do
+
+    let(:new_cluster_time) do
+      { 'clusterTime' => BSON::Timestamp.new(0, 5) }
+    end
+
+    context 'when the session does not have a cluster time' do
+
+      before do
+        session.advance_cluster_time(new_cluster_time)
+      end
+
+      it 'sets the new cluster time' do
+        expect(session.cluster_time).to eq(new_cluster_time)
+      end
+    end
+
+    context 'when the session already has a cluster time' do
+
+      context 'when the original cluster time is less than the new cluster time' do
+
+        let(:original_cluster_time) do
+          { 'clusterTime' => BSON::Timestamp.new(0, 1) }
+        end
+
+        before do
+          session.instance_variable_set(:@cluster_time, original_cluster_time)
+          session.advance_cluster_time(new_cluster_time)
+        end
+
+        it 'sets the new cluster time' do
+          expect(session.cluster_time).to eq(new_cluster_time)
+        end
+      end
+
+      context 'when the original cluster time is equal or greater than the new cluster time' do
+
+        let(:original_cluster_time) do
+          { 'clusterTime' => BSON::Timestamp.new(0, 6) }
+        end
+
+        before do
+          session.instance_variable_set(:@cluster_time, original_cluster_time)
+          session.advance_cluster_time(new_cluster_time)
+        end
+
+        it 'does not update the cluster time' do
+          expect(session.cluster_time).to eq(original_cluster_time)
+        end
+      end
+    end
+  end
+
+  describe '#advance_operation_time' do
+
+    let(:new_operation_time) do
+      BSON::Timestamp.new(0, 5)
+    end
+
+    context 'when the session does not have an operation time' do
+
+      before do
+        session.advance_operation_time(new_operation_time)
+      end
+
+      it 'sets the new operation time' do
+        expect(session.operation_time).to eq(new_operation_time)
+      end
+    end
+
+    context 'when the session already has an operation time' do
+
+      context 'when the original operation time is less than the new operation time' do
+
+        let(:original_operation_time) do
+          BSON::Timestamp.new(0, 1)
+        end
+
+        before do
+          session.instance_variable_set(:@operation_time, original_operation_time)
+          session.advance_operation_time(new_operation_time)
+        end
+
+        it 'sets the new operation time' do
+          expect(session.operation_time).to eq(new_operation_time)
+        end
+      end
+
+      context 'when the original operation time is equal or greater than the new operation time' do
+
+        let(:original_operation_time) do
+          BSON::Timestamp.new(0, 6)
+        end
+
+        before do
+          session.instance_variable_set(:@operation_time, original_operation_time)
+          session.advance_operation_time(new_operation_time)
+        end
+
+        it 'does not update the operation time' do
+          expect(session.operation_time).to eq(original_operation_time)
+        end
+      end
+    end
+  end
+
+  describe 'ended?' do
+
+    context 'when the session has not been ended' do
+
+      it 'returns false' do
+        expect(session.ended?).to be(false)
+      end
+    end
+
+    context 'when the session has been ended' do
+
+      before do
+        session.end_session
+      end
+
+      it 'returns true' do
+        expect(session.ended?).to be(true)
+      end
+    end
+  end
+
+  describe 'end_session' do
+
+    let!(:server_session) do
+      session.instance_variable_get(:@server_session)
+    end
+
+    let(:client_session_pool) do
+      session.client.instance_variable_get(:@session_pool)
+    end
+
+    it 'returns the server session to the client session pool' do
+      session.end_session
+      expect(client_session_pool.instance_variable_get(:@queue)).to include(server_session)
+    end
+
+    context 'when #end_session is called multiple times' do
+
+      before do
+        session.end_session
+      end
+
+      it 'returns nil' do
+        expect(session.end_session).to be_nil
+      end
+    end
+  end
+
+  describe '#retry_writes?', if: test_sessions? do
+
+    context 'when the option is set to true' do
+
+      let(:client) do
+        authorized_client.with(retry_writes: true)
+      end
+
+      it 'returns true' do
+        expect(client.start_session.retry_writes?).to be(true)
+      end
+    end
+
+    context 'when the option is set to false' do
+
+      let(:client) do
+        authorized_client.with(retry_writes: false)
+      end
+
+      it 'returns false' do
+        expect(client.start_session.retry_writes?).to be(false)
+      end
+    end
+
+    context 'when the option is not defined' do
+
+      let(:client) do
+        authorized_client
+      end
+
+      it 'returns false' do
+        expect(client.start_session.retry_writes?).to be(false)
+      end
+    end
+  end
+end