mongo 2.5.3 → 2.6.0

data/spec/integration/command_monitoring_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+class TestCommandMonitoringSubscriber
+  def initialize
+    @started_events = []
+    @succeeded_events = []
+    @failed_events = []
+  end
+
+  attr_reader :started_events, :succeeded_events, :failed_events
+
+  def started(event)
+    @started_events << event
+  end
+
+  def succeeded(event)
+    @succeeded_events << event
+  end
+
+  def failed(event)
+    @failed_events << event
+  end
+end
+
+describe 'Command monitoring' do
+  let(:subscriber) { TestCommandMonitoringSubscriber.new }
+
+  before do
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  after do
+    Mongo::Monitoring::Global.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  let(:client) { Mongo::Client.new(authorized_client.cluster.addresses.map(&:to_s), authorized_client.options) }
+
+  it 'notifies on successful commands' do
+    result = client.database.command(:ismaster => 1)
+    expect(result.documents.first['ismaster']).to be true
+
+    started_events = subscriber.started_events.select do |event|
+      event.command_name == 'ismaster'
+    end
+    expect(started_events.length).to eql(1)
+    started_event = started_events.first
+    expect(started_event.command_name).to eql('ismaster')
+    expect(started_event.address).to be_a(Mongo::Address)
+
+    succeeded_events = subscriber.succeeded_events.select do |event|
+      event.command_name == 'ismaster'
+    end
+    expect(succeeded_events.length).to eql(1)
+    succeeded_event = succeeded_events.first
+    expect(succeeded_event.command_name).to eql('ismaster')
+    expect(succeeded_event.reply).to be_a(BSON::Document)
+    expect(succeeded_event.reply['ismaster']).to eql(true)
+    expect(succeeded_event.address).to be_a(Mongo::Address)
+    expect(succeeded_event.duration).to be_a(Float)
+
+    expect(subscriber.failed_events.length).to eql(0)
+  end
+
+  it 'notifies on failed commands' do
+    expect do
+      result = client.database.command(:bogus => 1)
+    end.to raise_error(Mongo::Error::OperationFailure, /no such c(om)?m(an)?d/)
+
+    started_events = subscriber.started_events.select do |event|
+      event.command_name == 'bogus'
+    end
+    expect(started_events.length).to eql(1)
+    started_event = started_events.first
+    expect(started_event.command_name).to eql('bogus')
+    expect(started_event.address).to be_a(Mongo::Address)
+
+    succeeded_events = subscriber.succeeded_events.select do |event|
+      event.command_name == 'ismaster'
+    end
+    expect(succeeded_events.length).to eql(0)
+
+    failed_events = subscriber.failed_events.select do |event|
+      event.command_name == 'bogus'
+    end
+    expect(failed_events.length).to eql(1)
+    failed_event = failed_events.first
+    expect(failed_event.command_name).to eql('bogus')
+    expect(failed_event.message).to match(/no such c(om)?m(an)?d/)
+    expect(failed_event.address).to be_a(Mongo::Address)
+    expect(failed_event.duration).to be_a(Float)
+  end
+end

data/spec/lite_spec_helper.rb

@@ -0,0 +1,63 @@
+COVERAGE_MIN = 90
+CURRENT_PATH = File.expand_path(File.dirname(__FILE__))
+SERVER_DISCOVERY_TESTS = Dir.glob("#{CURRENT_PATH}/support/sdam/**/*.yml")
+SDAM_MONITORING_TESTS = Dir.glob("#{CURRENT_PATH}/support/sdam_monitoring/*.yml")
+SERVER_SELECTION_RTT_TESTS = Dir.glob("#{CURRENT_PATH}/support/server_selection/rtt/*.yml")
+SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/support/server_selection/selection/**/*.yml")
+MAX_STALENESS_TESTS = Dir.glob("#{CURRENT_PATH}/support/max_staleness/**/*.yml")
+CRUD_TESTS = Dir.glob("#{CURRENT_PATH}/support/crud_tests/**/*.yml")
+RETRYABLE_WRITES_TESTS = Dir.glob("#{CURRENT_PATH}/support/retryable_writes_tests/**/*.yml")
+COMMAND_MONITORING_TESTS = Dir.glob("#{CURRENT_PATH}/support/command_monitoring/**/*.yml")
+CONNECTION_STRING_TESTS = Dir.glob("#{CURRENT_PATH}/support/connection_string_tests/*.yml")
+DNS_SEEDLIST_DISCOVERY_TESTS = Dir.glob("#{CURRENT_PATH}/support/dns_seedlist_discovery_tests/*.yml")
+GRIDFS_TESTS = Dir.glob("#{CURRENT_PATH}/support/gridfs_tests/*.yml")
+TRANSACTIONS_TESTS = Dir.glob("#{CURRENT_PATH}/support/transactions_tests/*.yml")
+CHANGE_STREAMS_TESTS = Dir.glob("#{CURRENT_PATH}/support/change_streams_tests/*.yml")
+
+if ENV['DRIVERS_TOOLS']
+  CLIENT_CERT_PEM = ENV['DRIVER_TOOLS_CLIENT_CERT_PEM']
+  CLIENT_KEY_PEM = ENV['DRIVER_TOOLS_CLIENT_KEY_PEM']
+  CA_PEM = ENV['DRIVER_TOOLS_CA_PEM']
+  CLIENT_KEY_ENCRYPTED_PEM = ENV['DRIVER_TOOLS_CLIENT_KEY_ENCRYPTED_PEM']
+else
+  SSL_CERTS_DIR = "#{CURRENT_PATH}/support/certificates"
+  CLIENT_PEM = "#{SSL_CERTS_DIR}/client.pem"
+  CLIENT_PASSWORD_PEM = "#{SSL_CERTS_DIR}/password_protected.pem"
+  CA_PEM = "#{SSL_CERTS_DIR}/ca.pem"
+  CRL_PEM = "#{SSL_CERTS_DIR}/crl.pem"
+  CLIENT_KEY_PEM = "#{SSL_CERTS_DIR}/client_key.pem"
+  CLIENT_CERT_PEM = "#{SSL_CERTS_DIR}/client_cert.pem"
+  CLIENT_KEY_ENCRYPTED_PEM = "#{SSL_CERTS_DIR}/client_key_encrypted.pem"
+  CLIENT_KEY_PASSPHRASE = "passphrase"
+end
+
+require 'mongo'
+begin
+  require 'byebug'
+rescue LoadError
+end
+
+Mongo::Logger.logger = Logger.new($stdout)
+unless %w(1 true yes).include?((ENV['CLIENT_DEBUG'] || '').downcase)
+  Mongo::Logger.logger.level = Logger::INFO
+end
+Encoding.default_external = Encoding::UTF_8
+
+require 'support/matchers'
+require 'support/event_subscriber'
+require 'support/server_discovery_and_monitoring'
+require 'support/server_selection_rtt'
+require 'support/server_selection'
+require 'support/sdam_monitoring'
+require 'support/crud'
+require 'support/command_monitoring'
+require 'support/connection_string'
+require 'support/gridfs'
+require 'support/transactions'
+require 'support/change_streams'
+
+RSpec.configure do |config|
+  if ENV['CI'] && RUBY_PLATFORM =~ /\bjava\b/
+    config.formatter = 'documentation'
+  end
+end

data/spec/mongo/address/ipv6_spec.rb

@@ -15,12 +15,40 @@ describe Mongo::Address::IPv6 do
       end
     end
 
-    context 'when no port is provided' do
+    context 'when no port is provided and host is in brackets' do
 
       it 'returns the host and port' do
         expect(described_class.parse('[::1]')).to eq(['::1', 27017])
       end
     end
+
+    context 'when no port is provided and host is not in brackets' do
+
+      it 'returns the host and port' do
+        expect(described_class.parse('::1')).to eq(['::1', 27017])
+      end
+    end
+
+    context 'when invalid address is provided' do
+
+      it 'raises ArgumentError' do
+        expect do
+          described_class.parse('::1:27017')
+        end.to raise_error(ArgumentError, 'Invalid IPv6 address: ::1:27017')
+      end
+
+      it 'rejects extra data around the address' do
+        expect do
+          described_class.parse('[::1]:27017oh')
+        end.to raise_error(ArgumentError, 'Invalid IPv6 address: [::1]:27017oh')
+      end
+
+      it 'rejects bogus data in brackets' do
+        expect do
+          described_class.parse('[::hello]:27017')
+        end.to raise_error(ArgumentError, 'Invalid IPv6 address: [::hello]:27017')
+      end
+    end
   end
 
   describe '#initialize' do

data/spec/mongo/address_spec.rb

@@ -276,4 +276,38 @@ describe Mongo::Address do
       end
     end
   end
+  
+  describe '#to_s' do
+    context 'address with ipv4 host only' do
+      let(:address) { Mongo::Address.new('127.0.0.1') }
+      
+      it 'is host with port' do
+        expect(address.to_s).to eql('127.0.0.1:27017')
+      end
+    end
+    
+    context 'address with ipv4 host and port' do
+      let(:address) { Mongo::Address.new('127.0.0.1:27000') }
+      
+      it 'is host with port' do
+        expect(address.to_s).to eql('127.0.0.1:27000')
+      end
+    end
+    
+    context 'address with ipv6 host only' do
+      let(:address) { Mongo::Address.new('::1') }
+      
+      it 'is host with port' do
+        expect(address.to_s).to eql('[::1]:27017')
+      end
+    end
+    
+    context 'address with ipv6 host and port' do
+      let(:address) { Mongo::Address.new('[::1]:27000') }
+      
+      it 'is host with port' do
+        expect(address.to_s).to eql('[::1]:27000')
+      end
+    end
+  end
 end

data/spec/mongo/auth/scram/conversation_spec.rb

@@ -2,195 +2,401 @@ require 'spec_helper'
 
 describe Mongo::Auth::SCRAM::Conversation do
 
-  let(:user) do
-    Mongo::Auth::User.new(
-      database: Mongo::Database::ADMIN,
-      user: 'user',
-      password: 'pencil'
-    )
-  end
-
   let(:conversation) do
-    described_class.new(user)
+    described_class.new(user, mechanism)
   end
 
-  describe '#start' do
+  context 'when SCRAM-SHA-1 is used', if: scram_sha_1_enabled? do
 
-    let(:query) do
-      conversation.start
+    let(:user) do
+      Mongo::Auth::User.new(
+        database: Mongo::Database::ADMIN,
+        user: 'user',
+        password: 'pencil',
+        # We specify SCRAM-SHA-1 so that we don't accidentally use SCRAM-SHA-256 on newer server versions.
+        auth_mech: 'SCRAM-SHA-1'
+      )
     end
 
-    before do
-      expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
+    let(:mechanism) do
+      'SCRAM-SHA-1'
     end
 
-    let(:selector) do
-      query.selector
-    end
+    describe '#start' do
 
-    it 'sets the sasl start flag' do
-      expect(selector[:saslStart]).to eq(1)
-    end
+      let(:query) do
+        conversation.start
+      end
 
-    it 'sets the auto authorize flag' do
-      expect(selector[:autoAuthorize]).to eq(1)
-    end
+      before do
+        expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
+      end
 
-    it 'sets the mechanism' do
-      expect(selector[:mechanism]).to eq('SCRAM-SHA-1')
-    end
+      let(:selector) do
+        query.selector
+      end
 
-    it 'sets the payload' do
-      expect(selector[:payload].data).to eq('n,,n=user,r=NDA2NzU3MDY3MDYwMTgy')
-    end
-  end
+      it 'sets the sasl start flag' do
+        expect(selector[:saslStart]).to eq(1)
+      end
 
-  describe '#continue' do
+      it 'sets the auto authorize flag' do
+        expect(selector[:autoAuthorize]).to eq(1)
+      end
 
-    let(:reply) do
-      Mongo::Protocol::Message.new
-    end
+      it 'sets the mechanism' do
+        expect(selector[:mechanism]).to eq('SCRAM-SHA-1')
+      end
 
-    let(:documents) do
-      [{
-        'conversationId' => 1,
-        'done' => false,
-        'payload' => payload,
-        'ok' => 1.0
-      }]
+      it 'sets the payload' do
+        expect(selector[:payload].data).to eq('n,,n=user,r=NDA2NzU3MDY3MDYwMTgy')
+      end
     end
 
-    before do
-      expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
-      allow(reply).to receive(:documents).and_return(documents)
+    describe '#continue' do
+
+      let(:reply) do
+        Mongo::Protocol::Message.new
+      end
+
+      let(:documents) do
+        [{
+          'conversationId' => 1,
+          'done' => false,
+          'payload' => payload,
+          'ok' => 1.0
+        }]
+      end
+
+      before do
+        expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
+        allow(reply).to receive(:documents).and_return(documents)
+      end
+
+      context 'when the server rnonce starts with the nonce' do
+
+        let(:payload) do
+          BSON::Binary.new(
+            'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
+          )
+        end
+
+        let(:query) do
+          conversation.continue(reply)
+        end
+
+        let(:selector) do
+          query.selector
+        end
+
+        it 'sets the conversation id' do
+          expect(selector[:conversationId]).to eq(1)
+        end
+
+        it 'sets the payload' do
+          expect(selector[:payload].data).to eq(
+            'c=biws,r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,p=qYUYNy6SQ9Jucq9rFA9nVgXQdbM='
+          )
+        end
+
+        it 'sets the continue flag' do
+          expect(selector[:saslContinue]).to eq(1)
+        end
+      end
+
+      context 'when the server nonce does not start with the nonce' do
+
+        let(:payload) do
+          BSON::Binary.new(
+            'r=NDA2NzU4MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
+          )
+        end
+
+        it 'raises an error' do
+          expect {
+            conversation.continue(reply)
+          }.to raise_error(Mongo::Error::InvalidNonce)
+        end
+      end
     end
 
-    context 'when the server rnonce starts with the nonce' do
+    describe '#finalize' do
+
+      let(:continue_reply) do
+        Mongo::Protocol::Message.new
+      end
+
+      let(:continue_documents) do
+        [{
+          'conversationId' => 1,
+          'done' => false,
+          'payload' => continue_payload,
+          'ok' => 1.0
+        }]
+      end
 
-      let(:payload) do
+      let(:continue_payload) do
         BSON::Binary.new(
           'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
         )
       end
 
+      let(:reply) do
+        Mongo::Protocol::Message.new
+      end
+
+      let(:documents) do
+        [{
+          'conversationId' => 1,
+          'done' => false,
+          'payload' => payload,
+          'ok' => 1.0
+        }]
+      end
+
+      before do
+        expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
+        allow(continue_reply).to receive(:documents).and_return(continue_documents)
+        allow(reply).to receive(:documents).and_return(documents)
+      end
+
+      context 'when the verifier matches the server signature' do
+
+        let(:payload) do
+          BSON::Binary.new('v=gwo9E8+uifshm7ixj441GvIfuUY=')
+        end
+
+        let(:query) do
+          conversation.continue(continue_reply)
+          conversation.finalize(reply)
+        end
+
+        let(:selector) do
+          query.selector
+        end
+
+        it 'sets the conversation id' do
+          expect(selector[:conversationId]).to eq(1)
+        end
+
+        it 'sets the empty payload' do
+          expect(selector[:payload].data).to eq('')
+        end
+
+        it 'sets the continue flag' do
+          expect(selector[:saslContinue]).to eq(1)
+        end
+      end
+
+      context 'when the verifier does not match the server signature' do
+
+        let(:payload) do
+          BSON::Binary.new('v=LQ+8yhQeVL2a3Dh+TDJ7xHz4Srk=')
+        end
+
+        it 'raises an error' do
+          expect {
+            conversation.continue(continue_reply)
+            conversation.finalize(reply)
+          }.to raise_error(Mongo::Error::InvalidSignature)
+        end
+      end
+    end
+  end
+
+  context 'when SCRAM-SHA-256 is used', if: scram_sha_256_enabled? do
+
+    let(:user) do
+      Mongo::Auth::User.new(
+        database: Mongo::Database::ADMIN,
+        user: 'user',
+        password: 'pencil',
+        auth_mech: 'SCRAM-SHA-256'
+      )
+    end
+
+    let(:mechanism) do
+      'SCRAM-SHA-256'
+    end
+
+    describe '#start' do
+
       let(:query) do
-        conversation.continue(reply)
+        conversation.start
+      end
+
+      before do
+        expect(SecureRandom).to receive(:base64).once.and_return('rOprNGfwEbeRWgbNEkqO')
       end
 
       let(:selector) do
         query.selector
       end
 
-      it 'sets the conversation id' do
-        expect(selector[:conversationId]).to eq(1)
+      it 'sets the sasl start flag' do
+        expect(selector[:saslStart]).to eq(1)
       end
 
-      it 'sets the payload' do
-        expect(selector[:payload].data).to eq(
-          'c=biws,r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,p=qYUYNy6SQ9Jucq9rFA9nVgXQdbM='
-        )
+      it 'sets the auto authorize flag' do
+        expect(selector[:autoAuthorize]).to eq(1)
+      end
+
+      it 'sets the mechanism' do
+        expect(selector[:mechanism]).to eq('SCRAM-SHA-256')
       end
 
-      it 'sets the continue flag' do
-        expect(selector[:saslContinue]).to eq(1)
+      it 'sets the payload' do
+        expect(selector[:payload].data).to eq('n,,n=user,r=rOprNGfwEbeRWgbNEkqO')
       end
     end
 
-    context 'when the server nonce does not start with the nonce' do
+    describe '#continue' do
 
-      let(:payload) do
-        BSON::Binary.new(
-          'r=NDA2NzU4MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
-        )
+      let(:reply) do
+        Mongo::Protocol::Message.new
       end
 
-      it 'raises an error' do
-        expect {
-          conversation.continue(reply)
-        }.to raise_error(Mongo::Error::InvalidNonce)
+      let(:documents) do
+        [{
+          'conversationId' => 1,
+          'done' => false,
+          'payload' => payload,
+          'ok' => 1.0
+        }]
       end
-    end
-  end
 
-  describe '#finalize' do
+      before do
+        expect(SecureRandom).to receive(:base64).once.and_return('rOprNGfwEbeRWgbNEkqO')
+        allow(reply).to receive(:documents).and_return(documents)
+      end
 
-    let(:continue_reply) do
-      Mongo::Protocol::Message.new
-    end
+      context 'when the server rnonce starts with the nonce' do
 
-    let(:continue_documents) do
-      [{
-        'conversationId' => 1,
-        'done' => false,
-        'payload' => continue_payload,
-        'ok' => 1.0
-      }]
-    end
+        let(:payload) do
+          BSON::Binary.new(
+            'r=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,s=W22ZaJ0SNY7soEsUEjb6gQ==,i=4096'
+          )
+        end
 
-    let(:continue_payload) do
-      BSON::Binary.new(
-        'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
-      )
-    end
+        let(:query) do
+          conversation.continue(reply)
+        end
 
-    let(:reply) do
-      Mongo::Protocol::Message.new
-    end
+        let(:selector) do
+          query.selector
+        end
 
-    let(:documents) do
-      [{
-        'conversationId' => 1,
-        'done' => false,
-        'payload' => payload,
-        'ok' => 1.0
-      }]
-    end
+        it 'sets the conversation id' do
+          expect(selector[:conversationId]).to eq(1)
+        end
 
-    before do
-      expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
-      allow(continue_reply).to receive(:documents).and_return(continue_documents)
-      allow(reply).to receive(:documents).and_return(documents)
+        it 'sets the payload' do
+          expect(selector[:payload].data).to eq(
+            'c=biws,r=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,p=dHzbZapWIk4jUhN+Ute9ytag9zjfMHgsqmmiz7AndVQ='
+          )
+        end
+
+        it 'sets the continue flag' do
+          expect(selector[:saslContinue]).to eq(1)
+        end
+      end
+
+      context 'when the server nonce does not start with the nonce' do
+
+        let(:payload) do
+          BSON::Binary.new(
+            'r=sOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,s=W22ZaJ0SNY7soEsUEjb6gQ==,i=4096'
+          )
+        end
+
+        it 'raises an error' do
+          expect {
+            conversation.continue(reply)
+          }.to raise_error(Mongo::Error::InvalidNonce)
+        end
+      end
     end
 
-    context 'when the verifier matches the server signature' do
+    describe '#finalize' do
 
-      let(:payload) do
-        BSON::Binary.new('v=gwo9E8+uifshm7ixj441GvIfuUY=')
+      let(:continue_reply) do
+        Mongo::Protocol::Message.new
       end
 
-      let(:query) do
-        conversation.continue(continue_reply)
-        conversation.finalize(reply)
+      let(:continue_documents) do
+        [{
+          'conversationId' => 1,
+          'done' => false,
+          'payload' => continue_payload,
+          'ok' => 1.0
+        }]
       end
 
-      let(:selector) do
-        query.selector
+      let(:continue_payload) do
+        BSON::Binary.new(
+          'r=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,s=W22ZaJ0SNY7soEsUEjb6gQ==,i=4096'
+        )
       end
 
-      it 'sets the conversation id' do
-        expect(selector[:conversationId]).to eq(1)
+      let(:reply) do
+        Mongo::Protocol::Message.new
       end
 
-      it 'sets the empty payload' do
-        expect(selector[:payload].data).to eq('')
+      let(:documents) do
+        [{
+          'conversationId' => 1,
+          'done' => false,
+          'payload' => payload,
+          'ok' => 1.0
+        }]
       end
 
-      it 'sets the continue flag' do
-        expect(selector[:saslContinue]).to eq(1)
+      before do
+        expect(SecureRandom).to receive(:base64).once.and_return('rOprNGfwEbeRWgbNEkqO')
+        allow(continue_reply).to receive(:documents).and_return(continue_documents)
+        allow(reply).to receive(:documents).and_return(documents)
       end
-    end
 
-    context 'when the verifier does not match the server signature' do
+      context 'when the verifier matches the server signature' do
 
-      let(:payload) do
-        BSON::Binary.new('v=LQ+8yhQeVL2a3Dh+TDJ7xHz4Srk=')
-      end
+        let(:payload) do
+          BSON::Binary.new(' v=6rriTRBi23WpRR/wtup+mMhUZUn/dB5nLTJRsjl95G4=')
+        end
 
-      it 'raises an error' do
-        expect {
+        let(:query) do
           conversation.continue(continue_reply)
           conversation.finalize(reply)
-        }.to raise_error(Mongo::Error::InvalidSignature)
+        end
+
+        let(:selector) do
+          query.selector
+        end
+
+        it 'sets the conversation id' do
+          expect(selector[:conversationId]).to eq(1)
+        end
+
+        it 'sets the empty payload' do
+          expect(selector[:payload].data).to eq('')
+        end
+
+        it 'sets the continue flag' do
+          expect(selector[:saslContinue]).to eq(1)
+        end
+      end
+
+      context 'when the verifier does not match the server signature' do
+
+        let(:payload) do
+          BSON::Binary.new('v=7rriTRBi23WpRR/wtup+mMhUZUn/dB5nLTJRsjl95G4=')
+        end
+
+        it 'raises an error' do
+          expect {
+            conversation.continue(continue_reply)
+            conversation.finalize(reply)
+          }.to raise_error(Mongo::Error::InvalidSignature)
+        end
       end
     end
   end