mongo 2.6.4 → 2.7.0.rc0

data/spec/mongo/address_spec.rb

@@ -225,24 +225,34 @@ describe Mongo::Address do
 
     context 'when providing a DNS entry that resolves to both IPv6 and IPv4' do
 
+      let(:custom_hostname) do
+        'not_localhost'
+      end
+
+      let(:ip) do
+        '127.0.0.1'
+      end
+
+      let(:address) do
+        Mongo::Address.new(custom_hostname)
+      end
+
       before do
-        address.instance_variable_set(:@resolver, nil)
         allow(::Socket).to receive(:getaddrinfo).and_return(
-          [ ["AF_INET6", 0, '::1', '::1', ::Socket::AF_INET6, 1, 6],
-            ["AF_INET", 0, socket_address_or_host, socket_address_or_host, ::Socket::AF_INET, 1, 6]]
+          [ ["AF_INET6", 0, '::2', '::2', ::Socket::AF_INET6, 1, 6],
+            ["AF_INET", 0, custom_hostname, ip, ::Socket::AF_INET, 1, 6]]
         )
       end
 
       it "attempts to use IPv6 and fallbacks to IPv4" do
-        expect(address.socket(0.0)).not_to be_nil
+        expect(address.socket(0.0).host).to eq(ip)
       end
     end
 
     context 'when creating a socket using the resolver' do
 
       before do
-        address.instance_variable_set(:@resolver, nil)
-        address.send(:initialize_resolver!, (SpecConfig.instance.ssl? ? SSL_OPTIONS : {}))
+        address.send(:create_resolver, SpecConfig.instance.ssl_options)
       end
 
       it 'uses the host, not the IP address' do
@@ -251,7 +261,7 @@ describe Mongo::Address do
 
       let(:socket) do
         if SpecConfig.instance.ssl?
-          address.socket(0.0, SSL_OPTIONS).instance_variable_get(:@tcp_socket)
+          address.socket(0.0, SpecConfig.instance.ssl_options).instance_variable_get(:@tcp_socket)
         else
           address.socket(0.0).instance_variable_get(:@socket)
         end

data/spec/mongo/auth/cr_spec.rb

@@ -18,21 +18,24 @@ describe Mongo::Auth::CR 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(:options).and_return({})
       allow(cl).to receive(:cluster_time).and_return(nil)
       allow(cl).to receive(:update_cluster_time)
     end
   end
 
-  let(:topology) do
-    double('topology')
-  end
+  declare_topology_double
 
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners,
+      SpecConfig.instance.test_options
+    ).tap do |server|
+      server.scan!
+    end
   end
 
   let(:connection) do
-    Mongo::Server::Connection.new(server, TEST_OPTIONS)
+    Mongo::Server::Connection.new(server, SpecConfig.instance.test_options)
   end
 
   describe '#login' do

data/spec/mongo/auth/ldap_spec.rb

@@ -18,25 +18,28 @@ describe Mongo::Auth::LDAP 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(:options).and_return({})
       allow(cl).to receive(:cluster_time).and_return(nil)
       allow(cl).to receive(:update_cluster_time)
     end
   end
 
-  let(:topology) do
-    double('topology')
-  end
+  declare_topology_double
 
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners,
+      SpecConfig.instance.test_options
+    ).tap do |server|
+      server.scan!
+    end
   end
 
   let(:connection) do
-    Mongo::Server::Connection.new(server, TEST_OPTIONS)
+    Mongo::Server::Connection.new(server, SpecConfig.instance.test_options)
   end
 
   let(:user) do
-    Mongo::Auth::User.new(database: TEST_DB, user: 'driver', password: 'password')
+    Mongo::Auth::User.new(database: SpecConfig.instance.test_db, user: 'driver', password: 'password')
   end
 
   describe '#login' do

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

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
-describe Mongo::Auth::SCRAM::Conversation do
+# fails intermittently on jruby in Evergreen
+describe Mongo::Auth::SCRAM::Conversation, retry: 3 do
 
   let(:conversation) do
     described_class.new(user, mechanism)
@@ -54,6 +55,7 @@ describe Mongo::Auth::SCRAM::Conversation do
     end
 
     describe '#continue' do
+      fails_on_jruby
 
       let(:reply) do
         Mongo::Protocol::Message.new
@@ -121,6 +123,7 @@ describe Mongo::Auth::SCRAM::Conversation do
     end
 
     describe '#finalize' do
+      fails_on_jruby
 
       let(:continue_reply) do
         Mongo::Protocol::Message.new

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

@@ -1,49 +1,32 @@
 require 'spec_helper'
 require 'cgi'
 
-# In order to properly test that a user that can be authenticated with either SCRAM-SHA-1 or
-# SCRAM-SHA-256 uses SCRAM-SHA-256 by default, we need to monkey patch the authenticate method to
-# save the authentication method chosen.
-#
-# Note that this will cease to be effective if the tests are parallelized, so another strategy for
-# testing the above condition will need to be implemented.
-module Mongo
-  class Server
-    class Connection
-      @last_mechanism_used = nil
-
-      class << self
-        attr_accessor :last_mechanism_used
-      end
-
-      alias old_authenticate! authenticate!
-
-      def authenticate!
-        Connection.last_mechanism_used = options[:auth_mech] || default_mechanism
-        old_authenticate!
-      end
-    end
-  end
-end
-
 describe 'SCRAM-SHA auth mechanism negotiation' do
   require_scram_sha_256_support
 
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
   URI_OPTION_MAP = {
     :auth_source => 'authsource',
     :replica_set => 'replicaSet',
   }
 
   let(:create_user!) do
-    ADMIN_AUTHORIZED_TEST_CLIENT.with(
-      database: 'admin',
-      app_name: 'this is used solely to force the new client to create its own cluster',
-    ).database.command(
-      createUser: user.name,
-      pwd: user.password,
-      roles: ['root'],
-      mechanisms: auth_mechanisms
-    ) rescue Mongo::Error::OperationFailure
+    ClientRegistry.instance.global_client('root_authorized_admin').tap do |client|
+      users = client.database.users
+      if users.info(user.name).any?
+        users.remove(user.name)
+      end
+      client.database.command(
+        createUser: user.name,
+        pwd: password,
+        roles: ['root'],
+        mechanisms: auth_mechanisms
+      )
+      client.close
+    end
   end
 
   let(:password) do
@@ -65,9 +48,9 @@ describe 'SCRAM-SHA auth mechanism negotiation' do
         o[:auth_mech] = auth_mech if auth_mech
       end
 
-      Mongo::Client.new(
+      new_local_client(
         SpecConfig.instance.addresses,
-        TEST_OPTIONS.merge(opts)
+        SpecConfig.instance.test_options.merge(opts)
       )
     end
 
@@ -217,7 +200,18 @@ describe 'SCRAM-SHA auth mechanism negotiation' do
           it 'authenticates successfully' do
             create_user!
 
+            mechanism = nil
+            # Negotiation currently happens on monitoring sockets,
+            # hence may be invoked more than once here
+            expect(Mongo::Auth).to receive(:get).at_least(:once).and_wrap_original do |m, *args|
+              # copy mechanism here rather than whole user
+              # in case something mutates mechanism later
+              mechanism = args.first.mechanism
+              m.call(*args)
+            end
+
             expect { result }.not_to raise_error
+            expect(mechanism).to eq(:scram)
           end
         end
 
@@ -230,9 +224,20 @@ describe 'SCRAM-SHA auth mechanism negotiation' do
           it 'authenticates successfully with SCRAM-SHA-256' do
             create_user!
 
-            Mongo::Server::Connection.last_mechanism_used = nil
+            mechanism = nil
+            # Negotiation currently happens on monitoring sockets,
+            # hence may be invoked more than once here
+            expect(Mongo::Auth).to receive(:get).at_least(:once).and_wrap_original do |m, *args|
+              if args.first.name == 'both'
+                # copy mechanism here rather than whole user
+                # in case something mutates mechanism later
+                mechanism = args.first.mechanism
+                m.call(*args)
+              end
+            end
+
             expect { result }.not_to raise_error
-            expect(Mongo::Server::Connection.last_mechanism_used).to eq(:scram256)
+            expect(mechanism).to eq(:scram256)
           end
         end
       end
@@ -334,7 +339,7 @@ describe 'SCRAM-SHA auth mechanism negotiation' do
     end
 
     let(:client) do
-      Mongo::Client.new(uri, SSL_OPTIONS)
+      new_local_client(uri, SpecConfig.instance.ssl_options)
     end
 
     context 'when the user exists' do
@@ -482,7 +487,18 @@ describe 'SCRAM-SHA auth mechanism negotiation' do
           it 'authenticates successfully' do
             create_user!
 
+            mechanism = nil
+            # Negotiation currently happens on monitoring sockets,
+            # hence may be invoked more than once here
+            expect(Mongo::Auth).to receive(:get).at_least(:once).and_wrap_original do |m, *args|
+              # copy mechanism here rather than whole user
+              # in case something mutates mechanism later
+              mechanism = args.first.mechanism
+              m.call(*args)
+            end
+
             expect { result }.not_to raise_error
+            expect(mechanism).to eq(:scram)
           end
         end
 
@@ -495,81 +511,23 @@ describe 'SCRAM-SHA auth mechanism negotiation' do
           it 'authenticates successfully with SCRAM-SHA-256' do
             create_user!
 
-            Mongo::Server::Connection.last_mechanism_used = nil
+            mechanism = nil
+            # Negotiation currently happens on monitoring sockets,
+            # hence may be invoked more than once here
+            expect(Mongo::Auth).to receive(:get).at_least(:once).and_wrap_original do |m, *args|
+              if args.first.name == 'both'
+                # copy mechanism here rather than whole user
+                # in case something mutates mechanism later
+                mechanism = args.first.mechanism
+                m.call(*args)
+              end
+            end
+
             expect { result }.not_to raise_error
-            expect(Mongo::Server::Connection.last_mechanism_used).to eq(:scram256)
+            expect(mechanism).to eq(:scram256)
           end
         end
       end
     end
-
-    context 'when the user does not exist' do
-
-      let(:auth_mech) do
-        nil
-      end
-
-      let(:user) do
-        Mongo::Auth::User.new(
-          user: 'nonexistent',
-          password: 'nonexistent',
-        )
-      end
-
-      it 'fails with a Mongo::Auth::Unauthorized error' do
-        expect { result }.to raise_error(Mongo::Auth::Unauthorized)
-      end
-    end
-
-    context 'when the username and password provided require saslprep' do
-
-      let(:auth_mech) do
-        nil
-      end
-
-      let(:auth_mechanisms) do
-        ['SCRAM-SHA-256']
-      end
-
-      context 'when the username and password as ASCII' do
-
-        let(:user) do
-          Mongo::Auth::User.new(
-            user: 'IX',
-            password: 'IX'
-          )
-        end
-
-        let(:password) do
-          "I\u00ADX"
-        end
-
-        it 'authenticates successfully after saslprepping password' do
-          create_user!
-
-          expect { result }.not_to raise_error
-        end
-      end
-
-      context 'when the username and password are non-ASCII' do
-
-        let(:user) do
-          Mongo::Auth::User.new(
-            user: "\u2168",
-            password: "\u2163"
-          )
-        end
-
-        let(:password) do
-          "I\u00ADV"
-        end
-
-        it 'authenticates successfully after saslprepping password' do
-          create_user!
-
-          expect { result }.not_to raise_error
-        end
-      end
-    end
   end
 end

data/spec/mongo/auth/scram_spec.rb

@@ -18,21 +18,24 @@ describe Mongo::Auth::SCRAM 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(:options).and_return({})
       allow(cl).to receive(:cluster_time).and_return(nil)
       allow(cl).to receive(:update_cluster_time)
     end
   end
 
-  let(:topology) do
-    double('topology')
-  end
+  declare_topology_double
 
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners,
+      SpecConfig.instance.test_options
+    ).tap do |server|
+      server.scan!
+    end
   end
 
   let(:connection) do
-    Mongo::Server::Connection.new(server, TEST_OPTIONS)
+    Mongo::Server::Connection.new(server, SpecConfig.instance.test_options)
   end
 
   context 'when SCRAM-SHA-1 is used' do

data/spec/mongo/auth/user/view_spec.rb

@@ -6,7 +6,7 @@ describe Mongo::Auth::User::View do
     described_class.new(root_authorized_client.database)
   end
 
-  after do
+  before do
     begin; view.remove('durran'); rescue; end
   end
 
@@ -260,6 +260,10 @@ describe Mongo::Auth::User::View do
 
     context 'when a session is not used' do
 
+      before do
+        view.remove('emily') rescue nil
+      end
+
       context 'when a user exists in the database' do
 
         before do
@@ -269,10 +273,6 @@ describe Mongo::Auth::User::View do
           )
         end
 
-        after do
-          view.remove('emily')
-        end
-
         it 'returns information for that user' do
           expect(view.info('emily')).to_not be_empty
         end

data/spec/mongo/auth/x509_spec.rb

@@ -18,25 +18,28 @@ describe Mongo::Auth::X509 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(:options).and_return({})
       allow(cl).to receive(:cluster_time).and_return(nil)
       allow(cl).to receive(:update_cluster_time)
     end
   end
 
-  let(:topology) do
-    double('topology')
-  end
+  declare_topology_double
 
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners,
+      SpecConfig.instance.test_options
+    ).tap do |server|
+      server.scan!
+    end
   end
 
   let(:connection) do
-    Mongo::Server::Connection.new(server, TEST_OPTIONS)
+    Mongo::Server::Connection.new(server, SpecConfig.instance.test_options)
   end
 
   let(:user) do
-    Mongo::Auth::User.new(database: TEST_DB, user: 'driver', password: 'password')
+    Mongo::Auth::User.new(database: SpecConfig.instance.test_db, user: 'driver', password: 'password')
   end
 
   describe '#login' do