mongo 2.4.3 → 2.5.0.beta

data/spec/mongo/protocol/query_spec.rb

@@ -296,4 +296,49 @@ describe Mongo::Protocol::Query do
       end
     end
   end
+
+  describe '#registry' do
+
+    context 'when the class is loaded' do
+
+      it 'registers the op code in the Protocol Registry' do
+        expect(Mongo::Protocol::Registry.get(described_class::OP_CODE)).to be(described_class)
+      end
+
+      it 'creates an #op_code instance method' do
+        expect(message.op_code).to eq(described_class::OP_CODE)
+      end
+    end
+  end
+
+  describe '#compress' do
+
+    context 'when the selector represents a command that can be compressed' do
+
+      let(:selector) do
+        { ping: 1 }
+      end
+
+      it 'returns a compressed message' do
+        expect(message.compress!('zlib')).to be_a(Mongo::Protocol::Compressed)
+      end
+    end
+
+    context 'when the selector represents a command for which compression is not allowed' do
+
+      Mongo::Monitoring::Event::Secure::REDACTED_COMMANDS.each do |command|
+
+        let(:selector) do
+          { command => 1 }
+        end
+
+        context "when the command is #{command}" do
+
+          it 'does not allow compression for the command' do
+            expect(message.compress!('zlib')).to be(message)
+          end
+        end
+      end
+    end
+  end
 end

data/spec/mongo/protocol/registry_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Mongo::Protocol::Registry do
+
+  describe ".get" do
+
+    context "when the type has a correspoding class" do
+
+      before do
+        described_class.register(Mongo::Protocol::Query::OP_CODE, Mongo::Protocol::Query)
+      end
+
+      let(:klass) do
+        described_class.get(Mongo::Protocol::Query::OP_CODE, "message")
+      end
+
+      it "returns the class" do
+        expect(klass).to eq(Mongo::Protocol::Query)
+      end
+    end
+
+    context "when the type has no corresponding class" do
+
+      it "raises an error" do
+        expect {
+          described_class.get(-100)
+        }.to raise_error(Mongo::Error::UnsupportedMessageType)
+      end
+    end
+  end
+end

data/spec/mongo/protocol/reply_spec.rb

@@ -178,4 +178,18 @@ describe Mongo::Protocol::Reply do
       end
     end
   end
+
+  describe '#registry' do
+
+    context 'when the class is loaded' do
+
+      it 'registers the op code in the Protocol Registry' do
+        expect(Mongo::Protocol::Registry.get(described_class::OP_CODE)).to be(described_class)
+      end
+
+      it 'creates an #op_code instance method' do
+        expect(reply.op_code).to eq(described_class::OP_CODE)
+      end
+    end
+  end
 end

data/spec/mongo/protocol/update_spec.rb

@@ -183,4 +183,18 @@ describe Mongo::Protocol::Update do
       end
     end
   end
+
+  describe '#registry' do
+
+    context 'when the class is loaded' do
+
+      it 'registers the op code in the Protocol Registry' do
+        expect(Mongo::Protocol::Registry.get(described_class::OP_CODE)).to be(described_class)
+      end
+
+      it 'creates an #op_code instance method' do
+        expect(message.op_code).to eq(described_class::OP_CODE)
+      end
+    end
+  end
 end

data/spec/mongo/retryable_spec.rb

@@ -29,7 +29,7 @@ describe Mongo::Retryable do
       end
 
       def write
-        write_with_retry do
+        write_with_retry(nil, Proc.new { cluster.next_primary }) do
           operation.execute
         end
       end
@@ -41,7 +41,11 @@ describe Mongo::Retryable do
   end
 
   let(:cluster) do
-    double('cluster')
+    double('cluster', next_primary: server_selector)
+  end
+
+  let(:server_selector) do
+    double('server_selector', select_server: double('server'))
   end
 
   let(:retryable) do

data/spec/mongo/sdam_spec.rb

@@ -63,6 +63,10 @@ describe 'Server Discovery and Monitoring' do
             expect(@client.cluster.replica_set_name).to eq(phase.outcome.set_name)
           end
 
+          it "sets the cluster logical session timeout minutes to #{phase.outcome.logical_session_timeout.inspect}" do
+            expect(@client.cluster.logical_session_timeout).to eq(phase.outcome.logical_session_timeout)
+          end
+
           it "has the expected servers in the cluster" do
             expect(cluster_addresses).to eq(phase_addresses)
           end

data/spec/mongo/server/connection_spec.rb

@@ -22,6 +22,8 @@ describe Mongo::Server::Connection do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      allow(cl).to receive(:cluster_time).and_return(nil)
+      allow(cl).to receive(:update_cluster_time)
     end
   end
 
@@ -334,11 +336,11 @@ describe Mongo::Server::Connection do
       it 'closes the socket and does not use it for subsequent requests' do
         t = Thread.new {
           # Kill the thread just before the reply is read
-          allow(Mongo::Protocol::Reply).to receive(:deserialize_header) { t.kill }
+          allow(Mongo::Protocol::Message).to receive(:deserialize_header) { t.kill }
           connection.dispatch([ query_bob ])
         }
         t.join
-        allow(Mongo::Protocol::Reply).to receive(:deserialize_header).and_call_original
+        allow(Mongo::Protocol::Message).to receive(:deserialize_header).and_call_original
         expect(connection.dispatch([ query_alice ]).documents.first['name']).to eq('alice')
       end
     end

data/spec/mongo/server/description_spec.rb

@@ -24,6 +24,7 @@ describe Mongo::Server::Description do
       'minWireVersion' => 0,
       'localTime' => Time.now,
       'lastWrite' => { 'lastWriteDate' => Time.now },
+      'logicalSessionTimeoutMinutes' => 7,
       'ok' => 1
     }
   end
@@ -832,6 +833,31 @@ describe Mongo::Server::Description do
     end
   end
 
+  describe '#logical_session_timeout_minutes' do
+
+    context 'when a logical session timeout value is in the config' do
+
+      let(:description) do
+        described_class.new(address, replica)
+      end
+
+      it 'returns the logical session timeout value' do
+        expect(description.logical_session_timeout).to eq(7)
+      end
+    end
+
+    context 'when a logical session timeout value is not in the config' do
+
+      let(:description) do
+        described_class.new(address, { 'ismaster' => true, 'ok' => 1 })
+      end
+
+      it 'returns nil' do
+        expect(description.logical_session_timeout).to be(nil)
+      end
+    end
+  end
+
   describe '#==' do
 
     let(:description) do
@@ -841,7 +867,8 @@ describe Mongo::Server::Description do
     let(:other) do
       described_class.new(address, replica.merge(
         'localTime' => 1,
-        'lastWrite' => { 'lastWriteDate' => 1 }
+        'lastWrite' => { 'lastWriteDate' => 1 },
+        'operationTime' => 1
       ))
     end
 

data/spec/mongo/session/server_session_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Mongo::Session::ServerSession do
+
+  describe '#initialize' do
+
+    it 'sets the last use variable to the current time' do
+      expect(described_class.new.last_use).to be_within(0.2).of(Time.now)
+    end
+
+    it 'sets a UUID as the session id' do
+      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
+end

data/spec/mongo/session/session_pool_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe Mongo::Session::SessionPool do
+
+  describe '.create' do
+
+    let(:client) do
+      authorized_client
+    end
+
+    let!(:pool) do
+      described_class.create(client)
+    end
+
+    it 'creates a session pool' do
+      expect(pool).to be_a(Mongo::Session::SessionPool)
+    end
+
+    it 'adds the pool as an instance variable on the client' do
+      expect(client.instance_variable_get(:@session_pool)).to eq(pool)
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:pool) do
+      described_class.new(authorized_client)
+    end
+
+    it 'sets the client' do
+      expect(pool.instance_variable_get(:@client)).to be(authorized_client)
+    end
+  end
+
+  describe 'checkout', if: sessions_enabled? do
+
+    let(:pool) do
+      described_class.new(authorized_client)
+    end
+
+    context 'when a session is checked out' do
+
+      let!(:session_a) do
+        pool.checkout
+      end
+
+      let!(:session_b) do
+        pool.checkout
+      end
+
+      before do
+        pool.checkin(session_a)
+        pool.checkin(session_b)
+      end
+
+      it 'is returned to the front of the queue' do
+        expect(pool.checkout).to be(session_b)
+        expect(pool.checkout).to be(session_a)
+      end
+    end
+
+    context 'when there are sessions about to expire in the queue' do
+
+      let(:old_session_a) do
+        pool.checkout
+      end
+
+      let(:old_session_b) do
+        pool.checkout
+      end
+
+      before do
+        pool.checkin(old_session_a)
+        pool.checkin(old_session_b)
+        allow(old_session_a).to receive(:last_use).and_return(Time.now - 1800)
+        allow(old_session_b).to receive(:last_use).and_return(Time.now - 1800)
+      end
+
+      context 'when a session is checked out' do
+
+        let(:checked_out_session) do
+          pool.checkout
+        end
+
+        it 'disposes of the old session and returns a new one' do
+          expect(checked_out_session).not_to be(old_session_a)
+          expect(checked_out_session).not_to be(old_session_b)
+          expect(pool.instance_variable_get(:@queue)).to be_empty
+        end
+      end
+    end
+
+    context 'when a sessions that is about to expire is checked in' do
+
+      let(:old_session_a) do
+        pool.checkout
+      end
+
+      let(:old_session_b) do
+        pool.checkout
+      end
+
+      before do
+        allow(old_session_a).to receive(:last_use).and_return(Time.now - 1800)
+        allow(old_session_b).to receive(:last_use).and_return(Time.now - 1800)
+        pool.checkin(old_session_a)
+        pool.checkin(old_session_b)
+      end
+
+      it 'disposes of the old sessions instead of adding them to the pool' do
+        expect(pool.checkout).not_to be(old_session_a)
+        expect(pool.checkout).not_to be(old_session_b)
+        expect(pool.instance_variable_get(:@queue)).to be_empty
+      end
+    end
+  end
+
+  describe '#end_sessions', if: sessions_enabled? do
+
+    let(:pool) do
+      described_class.create(client)
+    end
+
+    let!(:session_a) do
+      pool.checkout
+    end
+
+    let!(:session_b) do
+      pool.checkout
+    end
+
+    let(:client) do
+      authorized_client.with(heartbeat_frequency: 100).tap do |cl|
+        cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      end
+    end
+
+    let(:subscriber) 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
+
+    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
+
+    context 'when talking to a mongos', if: sessions_enabled? && sharded? 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))
+        expect(end_sessions_command.command[:$clusterTime]).to eq(client.cluster.cluster_time)
+      end
+    end
+
+    context 'when the number of ids is larger than 10_000' do
+
+      before do
+        queue = []
+        10_001.times do |i|
+          queue << double('session', session_id: i)
+        end
+        pool.instance_variable_set(:@queue, queue)
+        expect(Mongo::Operation::Commands::Command).to receive(:new).at_least(:twice)
+      end
+
+      let(:end_sessions_commands) do
+        subscriber.started_events.select { |c| c.command_name == :endSessions}
+      end
+
+      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])
+      end
+    end
+  end
+end

data/spec/mongo/uri_spec.rb

@@ -566,7 +566,7 @@ describe Mongo::URI do
 
           it 'raises an exception when read preference is accessed on the client' do
             expect {
-              Mongo::Client.new(string).read_preference
+              Mongo::Client.new(string).server_selector
             }.to raise_exception(Mongo::Error::InvalidServerPreference)
           end
         end
@@ -578,7 +578,7 @@ describe Mongo::URI do
           end
 
           it 'does not raise an exception until the read preference is used' do
-            expect(Mongo::Client.new(string).read_preference).to be_a(Mongo::ServerSelector::Secondary)
+            expect(Mongo::Client.new(string).read_preference).to eq(BSON::Document.new(mode: :secondary, max_staleness: 89))
           end
         end
       end
@@ -929,5 +929,34 @@ describe Mongo::URI do
         expect(Mongo::Client.new(string).options[:app_name]).to eq(:reports)
       end
     end
+
+    context 'when a supported compressors option is provided' do
+      let(:options) { "compressors=zlib" }
+
+      it 'sets the compressors as an array on the client' do
+        expect(Mongo::Client.new(string).options[:compressors]).to eq(['zlib'])
+      end
+    end
+
+    context 'when a non-supported compressors option is provided' do
+      let(:options) { "compressors=snoopy" }
+
+      let(:client) do
+        Mongo::Client.new(string)
+      end
+
+      it 'sets no compressors on the client and warns' do
+        expect(Mongo::Logger.logger).to receive(:warn)
+        expect(client.options[:compressors]).to be_nil
+      end
+    end
+
+    context 'when a zlibCompressionLevel option is provided' do
+      let(:options) { "zlibCompressionLevel=6" }
+
+      it 'sets the zlib compression level on the client' do
+        expect(Mongo::Client.new(string).options[:zlib_compression_level]).to eq(6)
+      end
+    end
   end
 end