mongo 2.6.4 → 2.7.0.rc0

data/spec/support/shared/server_selector.rb

@@ -7,14 +7,19 @@ def make_server(mode, options = {})
               'ismaster' => mode == :primary,
               'secondary' => mode != :primary,
               'tags' => tags,
-              'ok' => 1
+              'ok' => 1,
+              'minWireVersion' => 2, 'maxWireVersion' => 8,
               }
 
   listeners = Mongo::Event::Listeners.new
   monitoring = Mongo::Monitoring.new
   address = options[:address]
 
-  server = Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
+  cluster = double('cluster')
+  allow(cluster).to receive(:topology).and_return(topology)
+  allow(cluster).to receive(:app_metadata)
+  allow(cluster).to receive(:options).and_return({})
+  server = Mongo::Server.new(address, cluster, monitoring, listeners, SpecConfig.instance.test_options)
   description = Mongo::Server::Description.new(address, ismaster, average_round_trip_time)
   server.tap do |s|
     allow(s).to receive(:description).and_return(description)
@@ -38,46 +43,13 @@ shared_context 'server selector' do
   let(:monitoring) do
     Mongo::Monitoring.new(monitoring: false)
   end
-  let(:topology) do
-    double('topology')
-  end
-
-  before(:all) do
-    module Mongo
-      # We monkey-patch the server here, so the monitors do not run and no
-      # real TCP connection is attempted.
-      #
-      # @since 2.1.0
-      class Server
-
-        alias :original_initialize :initialize
-        def initialize(address, cluster, monitoring, event_listeners, options = {})
-          @address = address
-          @cluster = cluster
-          @monitoring = monitoring
-          @options = options.freeze
-          @monitor = Monitor.new(address, event_listeners, options)
-        end
+  declare_topology_double
 
-        alias :original_disconnect! :disconnect!
-        def disconnect!; true; end
-      end
-    end
-  end
-
-  after(:all) do
-
-    # Return the server implementation to its original for the other
-    # tests in the suite.
-    module Mongo
-      class Server
-        alias :initialize :original_initialize
-        remove_method(:original_initialize)
-
-        alias :disconnect! :original_disconnect!
-        remove_method(:original_disconnect!)
-      end
-    end
+  before do
+    # Do not run monitors and do not attempt real TCP connections
+    # in server selector tests
+    allow_any_instance_of(Mongo::Server).to receive(:start_monitoring)
+    allow_any_instance_of(Mongo::Server).to receive(:disconnect!)
   end
 end
 

data/spec/support/shared/session.rb

@@ -1,6 +1,8 @@
 shared_examples 'an operation using a session' do
 
-  describe 'operation execution', if: test_sessions? do
+  describe 'operation execution' do
+    min_server_version '3.6'
+    require_topology :replica_set, :sharded
 
     context 'when the session is created from the same client used for the operation' do
 
@@ -44,7 +46,7 @@ shared_examples 'an operation using a session' do
     context 'when a session from another client is provided' do
 
       let(:session) do
-        authorized_client_with_retry_writes.start_session
+        another_authorized_client.start_session
       end
 
       let(:operation_result) do
@@ -83,7 +85,9 @@ end
 
 shared_examples 'a failed operation using a session' do
 
-  context 'when the operation fails', if: test_sessions? do
+  context 'when the operation fails' do
+    min_server_version '3.6'
+    require_topology :replica_set, :sharded
 
     let!(:before_last_use) do
       session.instance_variable_get(:@server_session).last_use
@@ -262,7 +266,9 @@ shared_examples 'an operation supporting causally consistent reads' do
     end
   end
 
-  context 'when connected to replica set or sharded cluster', if: test_sessions? do
+  context 'when connected to replica set or sharded cluster' do
+    min_server_version '3.6'
+    require_topology :replica_set, :sharded
 
     context 'when the collection specifies a read concern' do
 
@@ -606,27 +612,40 @@ shared_examples 'an operation updating cluster time' do
     subscribed_client
   end
 
+  shared_examples_for 'does not update the cluster time of the cluster' do
+    it 'does not update the cluster time of the cluster' do
+      bct = before_cluster_time
+      reply_cluster_time
+      expect(client.cluster.cluster_time).to eq(before_cluster_time)
+    end
+  end
+
   context 'when the command is run once' do
 
     context 'when the server is version 3.6' do
+      min_server_version '3.6'
 
-      context 'when the cluster is sharded or a replica set', if: test_sessions? do
+      context 'when the cluster is sharded or a replica set' do
+        require_topology :replica_set, :sharded
 
-        let!(:reply_cluster_time) do
+        let(:reply_cluster_time) do
           operation_with_session
           EventSubscriber.succeeded_events[-1].reply['$clusterTime']
         end
 
         it 'updates the cluster time of the cluster' do
-          expect(cluster.cluster_time).to eq(reply_cluster_time)
+          rct = reply_cluster_time
+          expect(cluster.cluster_time).to eq(rct)
         end
 
         it 'updates the cluster time of the session' do
-          expect(session.cluster_time).to eq(reply_cluster_time)
+          rct = reply_cluster_time
+          expect(session.cluster_time).to eq(rct)
         end
       end
 
-      context 'when the server is a standalone', if: (standalone? && sessions_enabled?) do
+      context 'when the server is a standalone' do
+        require_topology :single
 
         let(:before_cluster_time) do
           client.cluster.cluster_time
@@ -637,41 +656,41 @@ shared_examples 'an operation updating cluster time' do
           EventSubscriber.succeeded_events[-1].reply['$clusterTime']
         end
 
-        it 'does not update the cluster time of the cluster' do
-          expect(before_cluster_time).to eq(before_cluster_time)
-        end
+        it_behaves_like 'does not update the cluster time of the cluster'
 
         it 'does not update the cluster time of the session' do
+          reply_cluster_time
           expect(session.cluster_time).to be_nil
         end
       end
     end
 
-    context 'when the server is less than version 3.6', if: !sessions_enabled? do
+    context 'when the server is less than version 3.6' do
+      max_server_version '3.4'
 
       let(:before_cluster_time) do
         client.cluster.cluster_time
       end
 
-      let!(:reply_cluster_time) do
+      let(:reply_cluster_time) do
         operation
         EventSubscriber.succeeded_events[-1].reply['$clusterTime']
       end
 
-      it 'does not update the cluster time of the cluster' do
-        expect(before_cluster_time).to eq(before_cluster_time)
-      end
+      it_behaves_like 'does not update the cluster time of the cluster'
     end
   end
 
   context 'when the command is run twice' do
 
-    let!(:reply_cluster_time) do
+    let(:reply_cluster_time) do
       operation_with_session
       EventSubscriber.succeeded_events[-1].reply['$clusterTime']
     end
 
-    context 'when the cluster is sharded or a replica set', if: test_sessions? do
+    context 'when the cluster is sharded or a replica set' do
+      min_server_version '3.6'
+      require_topology :replica_set, :sharded
 
       context 'when the session cluster time is advanced' do
 
@@ -721,6 +740,7 @@ shared_examples 'an operation updating cluster time' do
         end
 
         it 'includes the received cluster time in the second command' do
+          reply_cluster_time
           expect(second_command_cluster_time).to eq(reply_cluster_time)
         end
       end
@@ -738,8 +758,9 @@ shared_examples 'an operation updating cluster time' do
       end
 
       it 'does not update the cluster time of the cluster' do
+        bct = before_cluster_time
         second_command_cluster_time
-        expect(before_cluster_time).to eq(before_cluster_time)
+        expect(client.cluster.cluster_time).to eq(bct)
       end
     end
   end
@@ -751,8 +772,9 @@ shared_examples 'an operation updating cluster time' do
     end
 
     it 'does not update the cluster time of the cluster' do
+      bct = before_cluster_time
       operation
-      expect(before_cluster_time).to eq(before_cluster_time)
+      expect(client.cluster.cluster_time).to eq(bct)
     end
   end
 end
@@ -821,7 +843,7 @@ shared_examples 'an operation not using a session' do
       it 'does not raise an exception' do
         expect {
           operation_result
-        }.not_to raise_exception(Mongo::Error::InvalidSession)
+        }.not_to raise_exception
       end
     end
   end

data/spec/support/spec_config.rb

@@ -9,44 +9,83 @@ class SpecConfig
       @uri_options = Mongo::Options::Mapper.transform_keys_to_symbols(@mongodb_uri.uri_options)
       if @uri_options[:replica_set]
         @addresses = @mongodb_uri.servers
-        @connect = { connect: :replica_set, replica_set: @uri_options[:replica_set] }
+        @connect_options = { connect: :replica_set, replica_set: @uri_options[:replica_set] }
       elsif ENV['TOPOLOGY'] == 'sharded_cluster'
         @addresses = [ @mongodb_uri.servers.first ] # See SERVER-16836 for why we can only use one host:port
-        @connect = { connect: :sharded }
+        @connect_options = { connect: :sharded }
       else
         @addresses = @mongodb_uri.servers
-        @connect = { connect: :direct }
+        @connect_options = { connect: :direct }
+      end
+      if @uri_options[:ssl].nil?
+        @ssl = (ENV['SSL'] == 'ssl') || (ENV['SSL_ENABLED'] == 'true')
+      else
+        @ssl = @uri_options[:ssl]
       end
     else
       @addresses = ENV['MONGODB_ADDRESSES'] ? ENV['MONGODB_ADDRESSES'].split(',').freeze : [ '127.0.0.1:27017' ].freeze
       if ENV['RS_ENABLED']
-        @connect = { connect: :replica_set, replica_set: ENV['RS_NAME'] }
+        @connect_options = { connect: :replica_set, replica_set: ENV['RS_NAME'] }
       elsif ENV['SHARDED_ENABLED']
-        @connect = { connect: :sharded }
+        @connect_options = { connect: :sharded }
       else
-        @connect = { connect: :direct }
+        @connect_options = { connect: :direct }
       end
     end
   end
 
+  attr_reader :uri_options, :addresses, :connect_options
+
+  # Environment
+
+  def ci?
+    !!ENV['CI']
+  end
+
   def mri?
     !jruby?
   end
 
   def jruby?
-    RUBY_PLATFORM =~ /\bjava\b/
+    !!(RUBY_PLATFORM =~ /\bjava\b/)
   end
 
   def platform
     RUBY_PLATFORM
   end
 
+  # Test suite configuration
+
   def client_debug?
     %w(1 true yes).include?((ENV['CLIENT_DEBUG'] || '').downcase)
   end
 
-  attr_reader :uri_options, :addresses, :connect
+  def drivers_tools?
+    !!ENV['DRIVERS_TOOLS']
+  end
+
+  def active_support?
+    %w(1 true yes).include?(ENV['WITH_ACTIVE_SUPPORT'])
+  end
+
+  # What compressor to use, if any.
+  def compressors
+    if ENV['COMPRESSORS']
+      ENV['COMPRESSORS'].split(',')
+    else
+      nil
+    end
+  end
+
+  def retry_writes?
+    %w(yes true on 1).include?((ENV['RETRY_WRITES'] || '').downcase)
+  end
 
+  def ssl?
+    @ssl
+  end
+
+  # Username, not user object
   def user
     @mongodb_uri && @mongodb_uri.credentials[:user]
   end
@@ -60,14 +99,150 @@ class SpecConfig
   end
 
   def connect_replica_set?
-    connect[:connect] == :replica_set
+    connect_options[:connect] == :replica_set
+  end
+
+  # Derived data
+
+  # The write concern to use in the tests.
+  def write_concern
+    if connect_replica_set?
+      {w: 2}
+    else
+      {w: 1}
+    end
   end
 
   def any_port
     addresses.first.split(':')[1] || '27017'
   end
 
-  def ssl?
-    (ENV['SSL'] == 'ssl') || (ENV['SSL_ENABLED'] == 'true')
+  def spec_root
+    File.join(File.dirname(__FILE__), '..')
+  end
+
+  def ssl_certs_dir
+    "#{spec_root}/support/certificates"
+  end
+
+  def client_cert_pem
+    if drivers_tools?
+      ENV['DRIVER_TOOLS_CLIENT_CERT_PEM']
+    else
+      "#{ssl_certs_dir}/client_cert.pem"
+    end
+  end
+
+  def client_key_pem
+    if drivers_tools?
+      ENV['DRIVER_TOOLS_CLIENT_KEY_PEM']
+    else
+      "#{ssl_certs_dir}/client_key.pem"
+    end
+  end
+
+  # The default test database for all specs.
+  def test_db
+    'ruby-driver'.freeze
+  end
+
+  # Option hashes
+
+  def ssl_options
+    if ssl?
+      {
+        ssl: true,
+        ssl_verify: false,
+        ssl_cert:  client_cert_pem,
+        ssl_key:  client_key_pem,
+      }
+    else
+      {}
+    end
+  end
+
+  def compressor_options
+    if compressors
+      {compressors: compressors}
+    else
+      {}
+    end
+  end
+
+  def retry_writes_options
+    if retry_writes?
+      {retry_writes: true}
+    else
+      {}
+    end
+  end
+
+  # Base test options.
+  def base_test_options
+    {
+      max_pool_size: 1,
+      write: write_concern,
+      heartbeat_frequency: 20,
+      max_read_retries: 5,
+      # The test suite seems to perform a number of operations
+      # requiring server selection. Hence a timeout of 1 here,
+      # together with e.g. a misconfigured replica set,
+      # means the test suite hangs for about 4 seconds before
+      # failing.
+      # Server selection timeout of 1 is insufficient for evergreen.
+      server_selection_timeout: 2,
+      wait_queue_timeout: 2,
+      connect_timeout: 3,
+      max_idle_time: 5
+   }
+  end
+
+  # Options for test suite clients.
+  def test_options
+    base_test_options.merge(connect_options).
+      merge(ssl_options).merge(compressor_options).merge(retry_writes_options)
+  end
+
+  # User objects
+
+  # Gets the root system administrator user.
+  def root_user
+    Mongo::Auth::User.new(
+      user: user || 'root-user',
+      password: password || 'password',
+      roles: [
+        Mongo::Auth::Roles::USER_ADMIN_ANY_DATABASE,
+        Mongo::Auth::Roles::DATABASE_ADMIN_ANY_DATABASE,
+        Mongo::Auth::Roles::READ_WRITE_ANY_DATABASE,
+        Mongo::Auth::Roles::HOST_MANAGER,
+        Mongo::Auth::Roles::CLUSTER_ADMIN
+      ]
+    )
+  end
+
+  # Get the default test user for the suite on versions 2.6 and higher.
+  def test_user
+    Mongo::Auth::User.new(
+      database: test_db,
+      user: 'test-user',
+      password: 'password',
+      roles: [
+        { role: Mongo::Auth::Roles::READ_WRITE, db: test_db },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: test_db },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'invalid_database' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'invalid_database' },
+
+        # For transactions examples
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'hr' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'hr' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'reporting' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'reporting' },
+
+        # For transaction api spec tests
+        #{ role: Mongo::Auth::Roles::READ_WRITE, db: 'withTransaction-tests' },
+        #{ role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'withTransaction-tests' },
+
+      ]
+    )
   end
 end