mongo 2.11.2 → 2.13.0.beta1

data/spec/mongo/address/ipv4_spec.rb

@@ -65,7 +65,7 @@ describe Mongo::Address::IPv4 do
     context 'when ssl options are provided' do
 
       let(:socket) do
-        resolver.socket(5, :ssl => true)
+        resolver.socket(5, ssl: true)
       end
 
       it 'returns an ssl socket' do

data/spec/mongo/address_spec.rb

@@ -249,11 +249,7 @@ describe Mongo::Address do
       end
     end
 
-    context 'when creating a socket using the resolver' do
-
-      before do
-        address.send(:create_resolver, SpecConfig.instance.ssl_options)
-      end
+    context 'when creating a socket' do
 
       it 'uses the host, not the IP address' do
         expect(address.socket(0.0).host).to eq(socket_address_or_host)
@@ -281,7 +277,25 @@ describe Mongo::Address do
 
       if Socket.const_defined?(:TCP_KEEPIDLE)
         it 'sets the socket TCP_KEEPIDLE option' do
-          expect(socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPIDLE).int).to be <= 300
+          expect(socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPIDLE).int).to be <= 120
+        end
+      end
+    end
+
+    describe ':connect_timeout option' do
+      clean_slate
+
+      let(:address) { Mongo::Address.new('127.0.0.1') }
+
+      it 'defaults to 10' do
+        RSpec::Mocks.with_temporary_scope do
+          resolved_address = double('address')
+          # This test's expectation
+          expect(resolved_address).to receive(:socket).with(0, connect_timeout: 10)
+
+          expect(Mongo::Address::IPv4).to receive(:new).and_return(resolved_address)
+
+          address.socket(0)
         end
       end
     end
@@ -320,12 +334,4 @@ describe Mongo::Address do
       end
     end
   end
-
-  describe '#connect_timeout' do
-    let(:address) { Mongo::Address.new('127.0.0.1') }
-
-    it 'defaults to 10' do
-      expect(address.send(:connect_timeout)).to eq(10)
-    end
-  end
 end

data/spec/mongo/auth/cr_spec.rb

@@ -12,6 +12,10 @@ describe Mongo::Auth::CR do
 
   describe '#login' do
 
+    before do
+      connection.connect!
+    end
+
     context 'when the user is not authorized' do
 
       let(:user) do
@@ -23,16 +27,16 @@ describe Mongo::Auth::CR do
       end
 
       let(:cr) do
-        described_class.new(user)
+        described_class.new(user, connection)
       end
 
       let(:login) do
-        cr.login(connection).documents[0]
+        cr.login.documents[0]
       end
 
       it 'raises an exception' do
         expect {
-          cr.login(connection)
+          cr.login
         }.to raise_error(Mongo::Auth::Unauthorized)
       end
 
@@ -43,7 +47,7 @@ describe Mongo::Auth::CR do
         it 'does not compress the message' do
           expect(Mongo::Protocol::Compressed).not_to receive(:new)
           expect {
-            cr.login(connection)
+            cr.login
           }.to raise_error(Mongo::Auth::Unauthorized)
         end
       end
@@ -53,16 +57,20 @@ describe Mongo::Auth::CR do
   context 'when the user is authorized for the database' do
     max_server_fcv '2.6'
 
+    before do
+      connection.connect!
+    end
+
     let(:cr) do
-      described_class.new(root_user)
+      described_class.new(root_user, connection)
     end
 
     let(:login) do
-      cr.login(connection).documents[0]
+      cr.login
     end
 
     it 'logs the user into the connection' do
-      expect(cr.login(connection).documents[0]['ok']).to eq(1)
+      expect(login['ok']).to eq(1)
     end
   end
 end

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

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Mongo::Auth::Gssapi::Conversation do
+  require_mongo_kerberos
+
+  let(:user) do
+    Mongo::Auth::User.new(user: 'test')
+  end
+
+  let(:conversation) do
+    described_class.new(user, 'test.example.com')
+  end
+
+  let(:authenticator) do
+    double('authenticator')
+  end
+
+  let(:connection) do
+    double('connection')
+  end
+
+  before do
+    expect(Mongo::Auth::Gssapi::Authenticator).to receive(:new).
+      with(user, 'test.example.com').
+      and_return(authenticator)
+  end
+
+  context 'when the user has a realm', if: RUBY_PLATFORM == 'java' do
+
+    let(:user) do
+      Mongo::Auth::User.new(user: 'user1@MYREALM.ME')
+    end
+
+    it 'includes the realm in the username as it was provided' do
+      expect(conversation.user.name).to eq(user.name)
+    end
+  end
+
+  describe '#start' do
+
+    let(:query) do
+      conversation.start(connection)
+    end
+
+    let(:selector) do
+      query.selector
+    end
+
+    before do
+      expect(authenticator).to receive(:initialize_challenge).and_return('test')
+    end
+
+    it 'sets the sasl start flag' do
+      expect(selector[:saslStart]).to eq(1)
+    end
+
+    it 'sets the auto authorize flag' do
+      expect(selector[:autoAuthorize]).to eq(1)
+    end
+
+    it 'sets the mechanism' do
+      expect(selector[:mechanism]).to eq('GSSAPI')
+    end
+
+    it 'sets the payload', unless: BSON::Environment.jruby? do
+      expect(selector[:payload]).to start_with('test')
+    end
+
+    it 'sets the payload', if: BSON::Environment.jruby? do
+      expect(selector[:payload].data).to start_with('test')
+    end
+  end
+
+  describe '#finalize' do
+
+    let(:continue_token) do
+      BSON::Environment.jruby? ? BSON::Binary.new('testing') : 'testing'
+    end
+
+    context 'when the conversation is a success' do
+
+      let(:reply_document) do
+        BSON::Document.new(
+          'conversationId' => 1,
+          'done' => false,
+          'payload' => continue_token,
+          'ok' => 1.0,
+        )
+      end
+
+      let(:query) do
+        conversation.finalize(reply_document, connection)
+      end
+
+      let(:selector) do
+        query.selector
+      end
+
+      before do
+        expect(authenticator).to receive(:evaluate_challenge).
+          with('testing').and_return(continue_token)
+      end
+
+      it 'sets the conversation id' do
+        expect(selector[:conversationId]).to eq(1)
+      end
+
+      it 'sets the payload', unless: BSON::Environment.jruby? do
+        expect(selector[:payload]).to eq(continue_token)
+      end
+
+      it 'sets the payload', if: BSON::Environment.jruby? do
+        expect(selector[:payload].data).to eq(continue_token)
+      end
+
+      it 'sets the continue flag' do
+        expect(selector[:saslContinue]).to eq(1)
+      end
+    end
+  end
+end

data/spec/mongo/auth/invalid_mechanism_spec.rb

@@ -5,7 +5,7 @@ describe Mongo::Auth::InvalidMechanism do
     let(:exception) { described_class.new(:foo) }
 
     it 'includes all built in mechanisms' do
-      expect(exception.message).to eq(':foo is invalid, please use one of the following mechanisms: :mongodb_cr, :mongodb_x509, :plain, :scram, :scram256')
+      expect(exception.message).to eq(':foo is invalid, please use one of the following mechanisms: :aws, :gssapi, :mongodb_cr, :mongodb_x509, :plain, :scram, :scram256')
     end
   end
 end

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

@@ -11,7 +11,7 @@ describe Mongo::Auth::LDAP::Conversation do
   end
 
   let(:conversation) do
-    described_class.new(user)
+    described_class.new(user, double('connection'))
   end
 
   describe '#start' do

data/spec/mongo/auth/ldap_spec.rb

@@ -16,19 +16,23 @@ describe Mongo::Auth::LDAP do
 
   describe '#login' do
 
+    before do
+      connection.connect!
+    end
+
     context 'when the user is not authorized for the database' do
 
       let(:cr) do
-        described_class.new(user)
+        described_class.new(user, connection)
       end
 
       let(:login) do
-        cr.login(connection).documents[0]
+        cr.login.documents[0]
       end
 
-      it 'logs the user into the connection' do
+      it 'attempts to log the user into the connection' do
         expect {
-          cr.login(connection)
+          cr.login
         }.to raise_error(Mongo::Auth::Unauthorized)
       end
     end

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

@@ -1,151 +1,72 @@
-require 'spec_helper'
+require 'lite_spec_helper'
+require 'support/shared/scram_conversation'
 
-# fails intermittently on jruby in Evergreen
-describe Mongo::Auth::SCRAM::Conversation, retry: 3 do
+describe Mongo::Auth::Scram::Conversation do
+  # Test uses global assertions
+  clean_slate_for_all_if_possible
+
+  include_context 'scram conversation context'
 
   let(:conversation) do
-    described_class.new(user, mechanism)
+    described_class.new(user, double('connection'))
   end
 
-  let(:connection) do
-    double('connection').tap do |connection|
-      features = double('features')
-      allow(features).to receive(:op_msg_enabled?)
-      allow(connection).to receive(:features).and_return(features)
-      allow(connection).to receive(:server)
-    end
+  it_behaves_like 'scram conversation'
+
+  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,
+    )
   end
 
-  context 'when SCRAM-SHA-1 is used' do
-    min_server_fcv '3.0'
-
-    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,
-      )
-    end
-
-    let(:mechanism) do
-      :scram
-    end
-
-    describe '#start' do
-
-      let(:query) do
-        conversation.start(nil)
-      end
-
-      before do
-        expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
-      end
-
-      let(:selector) do
-        query.selector
-      end
-
-      it 'sets the sasl start flag' do
-        expect(selector[:saslStart]).to eq(1)
-      end
-
-      it 'sets the auto authorize flag' do
-        expect(selector[:autoAuthorize]).to eq(1)
-      end
+  let(:mechanism) do
+    :scram
+  end
 
-      it 'sets the mechanism' do
-        expect(selector[:mechanism]).to eq('SCRAM-SHA-1')
-      end
+  describe '#start' do
 
-      it 'sets the payload' do
-        expect(selector[:payload].data).to eq('n,,n=user,r=NDA2NzU3MDY3MDYwMTgy')
-      end
+    let(:query) do
+      conversation.start(nil)
     end
 
-    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, connection)
-        end
-
-        let(:selector) do
-          query.selector
-        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')
+    end
 
-        it 'sets the payload' do
-          expect(selector[:payload].data).to eq(
-            'c=biws,r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,p=qYUYNy6SQ9Jucq9rFA9nVgXQdbM='
-          )
-        end
+    let(:selector) do
+      query.selector
+    end
 
-        it 'sets the continue flag' do
-          expect(selector[:saslContinue]).to eq(1)
-        end
-      end
+    it 'sets the sasl start flag' do
+      expect(selector[:saslStart]).to eq(1)
+    end
 
-      context 'when the server nonce does not start with the nonce' do
+    it 'sets the auto authorize flag' do
+      expect(selector[:autoAuthorize]).to eq(1)
+    end
 
-        let(:payload) do
-          BSON::Binary.new(
-            'r=NDA2NzU4MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
-          )
-        end
+    it 'sets the mechanism' do
+      expect(selector[:mechanism]).to eq('SCRAM-SHA-1')
+    end
 
-        it 'raises an error' do
-          expect {
-            conversation.continue(reply, connection)
-          }.to raise_error(Mongo::Error::InvalidNonce)
-        end
-      end
+    it 'sets the payload' do
+      expect(selector[:payload].data).to eq('n,,n=user,r=NDA2NzU3MDY3MDYwMTgy')
     end
+  end
 
-    describe '#finalize' do
+  describe '#continue' do
+    include_context 'scram continue and finalize replies'
 
-      let(:continue_reply) do
-        Mongo::Protocol::Message.new
-      end
+    before do
+      expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
+    end
 
-      let(:continue_documents) do
-        [{
-          'conversationId' => 1,
-          'done' => false,
-          'payload' => continue_payload,
-          'ok' => 1.0
-        }]
-      end
+    context 'when the server rnonce starts with the nonce' do
 
       let(:continue_payload) do
         BSON::Binary.new(
@@ -153,263 +74,128 @@ describe Mongo::Auth::SCRAM::Conversation, retry: 3 do
         )
       end
 
-      let(:reply) do
-        Mongo::Protocol::Message.new
+      let(:query) do
+        conversation.continue(continue_document, connection)
       end
 
-      let(:documents) do
-        [{
-          'conversationId' => 1,
-          'done' => false,
-          'payload' => payload,
-          'ok' => 1.0
-        }]
+      let(:selector) do
+        query.selector
       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 conversation id' do
+        expect(selector[:conversationId]).to eq(1)
       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, connection)
-          conversation.finalize(reply, connection)
-        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 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
+      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
+    context 'when the server nonce does not start with the nonce' do
 
-        let(:payload) do
-          BSON::Binary.new('v=LQ+8yhQeVL2a3Dh+TDJ7xHz4Srk=')
-        end
+      let(:continue_payload) do
+        BSON::Binary.new(
+          'r=NDA2NzU4MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
+        )
+      end
 
-        it 'raises an error' do
-          expect {
-            conversation.continue(continue_reply, connection)
-            conversation.finalize(reply, connection)
-          }.to raise_error(Mongo::Error::InvalidSignature)
-        end
+      it 'raises an error' do
+        expect {
+          conversation.continue(continue_document, connection)
+        }.to raise_error(Mongo::Error::InvalidNonce)
       end
     end
   end
 
-  context 'when SCRAM-SHA-256 is used' do
-    min_server_fcv '4.0'
+  describe '#finalize' do
+    include_context 'scram continue and finalize replies'
 
-    let(:user) do
-      Mongo::Auth::User.new(
-        database: Mongo::Database::ADMIN,
-        user: 'user',
-        password: 'pencil',
-        auth_mech: :scram256,
+    let(:continue_payload) do
+      BSON::Binary.new(
+        'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
       )
     end
 
-    let(:mechanism) do
-      :scram256
+    before do
+      expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
     end
 
-    describe '#start' do
+    context 'when the verifier matches the server signature' do
 
-      let(:query) do
-        conversation.start(nil)
+      let(:finalize_payload) do
+        BSON::Binary.new('v=gwo9E8+uifshm7ixj441GvIfuUY=')
       end
 
-      before do
-        expect(SecureRandom).to receive(:base64).once.and_return('rOprNGfwEbeRWgbNEkqO')
+      let(:query) do
+        conversation.continue(continue_document, connection)
+        conversation.process_continue_response(finalize_document)
+        conversation.finalize(connection)
       end
 
       let(:selector) do
         query.selector
       end
 
-      it 'sets the sasl start flag' do
-        expect(selector[:saslStart]).to eq(1)
-      end
-
-      it 'sets the auto authorize flag' do
-        expect(selector[:autoAuthorize]).to eq(1)
+      it 'sets the conversation id' do
+        expect(selector[:conversationId]).to eq(1)
       end
 
-      it 'sets the mechanism' do
-        expect(selector[:mechanism]).to eq('SCRAM-SHA-256')
+      it 'sets the empty payload' do
+        expect(selector[:payload].data).to eq('')
       end
 
-      it 'sets the payload' do
-        expect(selector[:payload].data).to eq('n,,n=user,r=rOprNGfwEbeRWgbNEkqO')
+      it 'sets the continue flag' do
+        expect(selector[:saslContinue]).to eq(1)
       end
     end
 
-    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('rOprNGfwEbeRWgbNEkqO')
-        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=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,s=W22ZaJ0SNY7soEsUEjb6gQ==,i=4096'
-          )
-        end
+    context 'when the verifier does not match the server signature' do
 
-        let(:query) do
-          conversation.continue(reply, connection)
-        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=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,p=dHzbZapWIk4jUhN+Ute9ytag9zjfMHgsqmmiz7AndVQ='
-          )
-        end
-
-        it 'sets the continue flag' do
-          expect(selector[:saslContinue]).to eq(1)
-        end
+      let(:finalize_payload) do
+        BSON::Binary.new('v=LQ+8yhQeVL2a3Dh+TDJ7xHz4Srk=')
       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, connection)
-          }.to raise_error(Mongo::Error::InvalidNonce)
-        end
+      it 'raises an error' do
+        expect {
+          conversation.continue(continue_document, connection)
+          conversation.process_continue_response(finalize_document)
+          conversation.finalize(connection)
+        }.to raise_error(Mongo::Error::InvalidSignature)
       end
     end
 
-    describe '#finalize' do
+    context 'when server signature is empty' 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(:continue_payload) do
-        BSON::Binary.new(
-          'r=rOprNGfwEbeRWgbNEkqO%hvYDpWUa2RaTCAfuxFIlj)hNlF$k0,s=W22ZaJ0SNY7soEsUEjb6gQ==,i=4096'
-        )
+      let(:finalize_payload) do
+        BSON::Binary.new('v=')
       end
 
-      let(:reply) do
-        Mongo::Protocol::Message.new
+      it 'raises an error' do
+        expect {
+          conversation.continue(continue_document, connection)
+          conversation.process_continue_response(finalize_document)
+          conversation.finalize(connection)
+        }.to raise_error(Mongo::Error::InvalidSignature)
       end
+    end
 
-      let(:documents) do
-        [{
-          'conversationId' => 1,
-          'done' => false,
-          'payload' => payload,
-          'ok' => 1.0
-        }]
-      end
-
-      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
-
-      context 'when the verifier matches the server signature' do
-
-        let(:payload) do
-          BSON::Binary.new(' v=6rriTRBi23WpRR/wtup+mMhUZUn/dB5nLTJRsjl95G4=')
-        end
-
-        let(:query) do
-          conversation.continue(continue_reply, connection)
-          conversation.finalize(reply, connection)
-        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
+    context 'when server signature is not provided' do
 
-        it 'sets the continue flag' do
-          expect(selector[:saslContinue]).to eq(1)
-        end
+      let(:finalize_payload) do
+        BSON::Binary.new('ok=absolutely')
       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, connection)
-            conversation.finalize(reply, connection)
-          }.to raise_error(Mongo::Error::InvalidSignature)
-        end
+      it 'succeeds but does not mark conversation server verified' do
+        conversation.continue(continue_document, connection)
+        conversation.process_continue_response(finalize_document)
+        conversation.finalize(connection)
+        conversation.server_verified?.should be false
       end
     end
   end