mongoid 7.0.4 → 7.0.10

data/spec/mongoid/tasks/database_spec.rb

@@ -133,7 +133,7 @@ describe "Mongoid::Tasks::Database" do
       expect(removed_indexes).to be_empty
     end
 
-    context 'when the index is a text index', if: non_legacy_server? do
+    context 'when the index is a text index' do
 
       before do
         class Band

data/spec/mongoid/validatable/uniqueness_spec.rb

@@ -796,20 +796,47 @@ describe Mongoid::Validatable::UniquenessValidator do
           end
         end
 
-        context "when a range scope is provided" do
+        context "when a range condition is provided" do
 
           before do
-            Dictionary.validates_uniqueness_of(:name, :scope => Dictionary.where(:year.gte => 1900, :year.lt => 2000))
-            Dictionary.create(name: "French-English", year: 1950)
-            Dictionary.create(name: "French-English", year: 1960)
+            Dictionary.validates_uniqueness_of(:name,
+              conditions: -> { Dictionary.where(:year.gte => 1900, :year.lt => 2000) })
           end
 
           after do
             Dictionary.reset_callbacks(:validate)
           end
 
-          it "successfully prevents uniqueness violation" do
-            expect(Dictionary.all.size).to eq(1)
+          context 'when multiple documents would match the condition' do
+            it "prevents creation of new document" do
+              Dictionary.create!(name: "French-English", year: 1950)
+
+              expect do
+                Dictionary.create!(name: "French-English", year: 1960)
+              end.to raise_error(Mongoid::Errors::Validations, /Name is already taken/)
+
+              expect(Dictionary.all.size).to eq(1)
+            end
+          end
+
+          context 'when only new document would match the condition' do
+            it 'creates the new document' do
+              Dictionary.create!(name: "French-English", year: 950)
+              expect do
+                Dictionary.create!(name: "French-English", year: 1950)
+              end.not_to raise_error
+            end
+          end
+
+          context 'when only existing document matches the condition' do
+            it 'creates the new document' do
+              pending 'https://jira.mongodb.org/browse/MONGOID-4815'
+
+              Dictionary.create!(name: "French-English", year: 1950)
+              expect do
+                Dictionary.create!(name: "French-English", year: 950)
+              end.not_to raise_error
+            end
           end
         end
 

data/spec/spec_helper.rb

@@ -31,6 +31,7 @@ end
 require 'support/authorization'
 require 'support/expectations'
 require 'support/macros'
+require 'support/cluster_config'
 require 'support/constraints'
 
 # Give MongoDB time to start up on the travis ci environment.
@@ -74,42 +75,6 @@ CONFIG = {
   }
 }
 
-def non_legacy_server?
-  Mongoid::Clients.default.cluster.servers.first.features.write_command_enabled?
-end
-
-def testing_replica_set?
-  Mongoid::Clients.default.cluster.replica_set?
-end
-
-def collation_supported?
-  Mongoid::Clients.default.cluster.next_primary.features.collation_enabled?
-end
-alias :decimal128_supported? :collation_supported?
-
-def array_filters_supported?
-  Mongoid::Clients.default.cluster.next_primary.features.array_filters_enabled?
-end
-alias :sessions_supported? :array_filters_supported?
-
-def testing_geo_near?
-  $geo_near_enabled ||= (Mongoid::Clients.default
-                             .command(serverStatus: 1)
-                             .first['version'] < '4.1')
-end
-
-def transactions_supported?
-  Mongoid::Clients.default.cluster.next_primary.features.transactions_enabled?
-end
-
-def testing_transactions?
-  transactions_supported? && testing_replica_set?
-end
-
-def testing_locally?
-  !(ENV['CI'] == 'travis')
-end
-
 # Set the database that the spec suite connects to.
 Mongoid.configure do |config|
   config.load_configuration(CONFIG)
@@ -164,7 +129,9 @@ RSpec.configure do |config|
 
   # Drop all collections and clear the identity map before each spec.
   config.before(:each) do
-    unless Mongoid.default_client.cluster.connected?
+    cluster = Mongoid.default_client.cluster
+    # Older drivers do not have a #connected? method
+    if cluster.respond_to?(:connected?) && !cluster.connected?
       Mongoid.default_client.reconnect
     end
     Mongoid.default_client.collections.each do |coll|

data/spec/support/child_process_helper.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+autoload :ChildProcess, 'childprocess'
+autoload :Tempfile, 'tempfile'
+
+module ChildProcessHelper
+  module_function def call(cmd, env: nil, cwd: nil)
+    process = ChildProcess.new(*cmd)
+    process.io.inherit!
+    if cwd
+      process.cwd = cwd
+    end
+    if env
+      env.each do |k, v|
+        process.environment[k.to_s] = v
+      end
+    end
+    process.start
+    process.wait
+    process
+  end
+
+  module_function def check_call(cmd, env: nil, cwd: nil)
+    process = call(cmd, env: env, cwd: cwd)
+    unless process.exit_code == 0
+      raise "Failed to execute: #{cmd}"
+    end
+  end
+
+  module_function def get_output(cmd, env: nil, cwd: nil)
+    process = ChildProcess.new(*cmd)
+    process.io.inherit!
+    if cwd
+      process.cwd = cwd
+    end
+    if env
+      env.each do |k, v|
+        process.environment[k.to_s] = v
+      end
+    end
+
+    output = ''
+    r, w = IO.pipe
+
+    begin
+      process.io.stdout = w
+      process.start
+      w.close
+
+      thread = Thread.new do
+        begin
+          loop do
+            output << r.readpartial(16384)
+          end
+        rescue EOFError
+        end
+      end
+
+      process.wait
+      thread.join
+    ensure
+      r.close
+    end
+
+    [process, output]
+  end
+
+  module_function def check_output(*args)
+    process, output = get_output(*args)
+    unless process.exit_code == 0
+      raise "Failed to execute: #{args}"
+    end
+    output
+  end
+end

data/spec/support/cluster_config.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'singleton'
+
+class ClusterConfig
+  include Singleton
+
+  def single_server?
+    determine_cluster_config
+    @single_server
+  end
+
+  def replica_set_name
+    determine_cluster_config
+    @replica_set_name
+  end
+
+  def server_version
+    determine_cluster_config
+    @server_version
+  end
+
+  def short_server_version
+    server_version.split('.')[0..1].join('.')
+  end
+
+  def fcv
+    determine_cluster_config
+    @fcv
+  end
+
+  # Per https://jira.mongodb.org/browse/SERVER-39052, working with FCV
+  # in sharded topologies is annoying. Also, FCV doesn't exist in servers
+  # less than 3.4. This method returns FCV on 3.4+ servers when in single
+  # or RS topologies, and otherwise returns the major.minor server version.
+  def fcv_ish
+    if server_version >= '3.4' && topology != :sharded
+      fcv
+    else
+      if short_server_version == '4.1'
+        '4.2'
+      else
+        short_server_version
+      end
+    end
+  end
+
+  def primary_address
+    determine_cluster_config
+    @primary_address
+  end
+
+  def primary_address_str
+    determine_cluster_config
+    @primary_address.seed
+  end
+
+  def primary_address_host
+    both = primary_address_str
+    both.split(':').first
+  end
+
+  def primary_address_port
+    both = primary_address_str
+    both.split(':')[1] || 27017
+  end
+
+  def primary_description
+    determine_cluster_config
+    @primary_description
+  end
+
+  # Try running a command on the admin database to see if the mongod was
+  # started with auth.
+  def auth_enabled?
+    if @auth_enabled.nil?
+      @auth_enabled = begin
+        basic_client.use(:admin).command(getCmdLineOpts: 1).first["argv"].include?("--auth")
+      rescue => e
+        e.message =~ /(not authorized)|(unauthorized)|(no users authenticated)|(requires authentication)/
+      end
+    end
+    @auth_enabled
+  end
+
+  def topology
+    determine_cluster_config
+    @topology
+  end
+
+  def storage_engine
+    @storage_engine ||= begin
+      # 2.6 does not have wired tiger
+      if short_server_version == '2.6'
+        :mmapv1
+      else
+        client = ClientRegistry.instance.global_client('root_authorized')
+        if topology == :sharded
+          shards = client.use(:admin).command(listShards: 1).first
+          shard = shards['shards'].first
+          address_str = shard['host'].sub(/\A.*\//, '').sub(/,.*/, '')
+          client = ClusterTools.instance.direct_client(address_str,
+            SpecConfig.instance.test_options.merge(SpecConfig.instance.auth_options).merge(connect: :direct))
+        end
+        rv = client.use(:admin).command(serverStatus: 1).first
+        rv = rv['storageEngine']['name']
+        rv_map = {
+          'wiredTiger' => :wired_tiger,
+          'mmapv1' => :mmapv1,
+        }
+        rv_map[rv] || rv
+      end
+    end
+  end
+
+  private
+
+  def determine_cluster_config
+    return if @primary_address
+
+    # Run all commands to figure out the cluster configuration from the same
+    # client. This is somewhat wasteful when running a single test, but reduces
+    # test runtime for the suite overall because all commands are sent on the
+    # same connection rather than each command connecting to the cluster by
+    # itself.
+    client = Mongoid::Clients.default
+
+    primary = client.cluster.next_primary
+    @primary_address = primary.address
+    @primary_description = primary.description
+    @replica_set_name = client.cluster.topology.replica_set_name
+
+    @topology ||= begin
+      topology = client.cluster.topology.class.name.sub(/.*::/, '')
+      topology = topology.gsub(/([A-Z])/) { |match| '_' + match.downcase }.sub(/\A_/, '')
+      if topology =~ /\Areplica_set/
+        topology = 'replica_set'
+      end
+      topology.to_sym
+    end
+
+    @single_server = client.cluster.send(:servers_list).length == 1
+
+    @server_version = client.database.command(buildInfo: 1).first['version']
+
+    if @topology != :sharded && short_server_version >= '3.4'
+      rv = client.use(:admin).command(getParameter: 1, featureCompatibilityVersion: 1).first['featureCompatibilityVersion']
+      @fcv = rv['version'] || rv
+    end
+  end
+
+  def basic_client
+    # Do not cache the result here so that if the client gets closed,
+    # client registry reconnects it in subsequent tests
+    ClientRegistry.instance.global_client('basic')
+  end
+end

data/spec/support/constraints.rb

@@ -1,12 +1,31 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Constraints
   RAILS_VERSION = ActiveSupport.version.to_s.split('.')[0..1].join('.').freeze
 
+  def require_driver_query_cache
+    before(:all) do
+      if !defined?(Mongo::QueryCache)
+        skip "Driver version #{Mongo::VERSION} does not support query cache"
+      end
+    end
+  end
+
+  def require_mongoid_query_cache
+    before (:all) do
+      if defined?(Mongo::QueryCache)
+        skip "Mongoid uses the driver query cache in driver versions that support it"
+      end
+    end
+  end
+
   def min_rails_version(version)
-    unless version =~ /^\d+\.\d+$/
+    unless version =~ /\A\d+\.\d+\z/
       raise ArgumentError, "Version can only be major.minor: #{version}"
     end
 
-    before do
+    before(:all) do
       if version > RAILS_VERSION
         skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}"
       end
@@ -14,11 +33,11 @@ module Constraints
   end
 
   def max_rails_version(version)
-    unless version =~ /^\d+\.\d+$/
+    unless version =~ /\A\d+\.\d+\z/
       raise ArgumentError, "Version can only be major.minor: #{version}"
     end
 
-    before do
+    before(:all) do
       if version < RAILS_VERSION
         skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
       end
@@ -26,11 +45,11 @@ module Constraints
   end
 
   def min_server_version(version)
-    unless version =~ /^\d+\.\d+$/
+    unless version =~ /\A\d+\.\d+\z/
       raise ArgumentError, "Version can only be major.minor: #{version}"
     end
 
-    before do
+    before(:all) do
       if version > ClusterConfig.instance.server_version
         skip "Server version #{version} or higher required, we have #{ClusterConfig.instance.server_version}"
       end
@@ -38,11 +57,11 @@ module Constraints
   end
 
   def max_server_version(version)
-    unless version =~ /^\d+\.\d+$/
+    unless version =~ /\A\d+\.\d+\z/
       raise ArgumentError, "Version can only be major.minor: #{version}"
     end
 
-    before do
+    before(:all) do
       if version < ClusterConfig.instance.short_server_version
         skip "Server version #{version} or lower required, we have #{ClusterConfig.instance.server_version}"
       end
@@ -50,18 +69,14 @@ module Constraints
   end
 
   def require_topology(*topologies)
-    topologies = topologies.map { |t| t.to_s }
-    invalid_topologies = topologies - %w(single replica_set sharded)
+    invalid_topologies = topologies - [:single, :replica_set, :sharded]
+
     unless invalid_topologies.empty?
       raise ArgumentError, "Invalid topologies requested: #{invalid_topologies.join(', ')}"
     end
-    before do
-      topology = Mongoid.default_client.cluster.topology.class.name.sub(/.*::/, '')
-      topology = topology.gsub(/([A-Z])/) { |match| '_' + match.downcase }.sub(/^_/, '')
-      if topology =~ /^replica_set/
-        topology = 'replica_set'
-      end
-      unless topologies.include?(topology)
+
+    before(:all) do
+      unless topologies.include?(topology = ClusterConfig.instance.topology)
         skip "Topology #{topologies.join(' or ')} required, we have #{topology}"
       end
     end
@@ -69,32 +84,188 @@ module Constraints
 
   def max_example_run_time(timeout)
     around do |example|
-      TimeoutInterrupt.timeout(timeout) do
+      TimeoutInterrupt.timeout(timeout, TimeoutInterrupt::Error.new("Test execution terminated after #{timeout} seconds")) do
         example.run
       end
     end
   end
 
   def require_transaction_support
-    min_server_version '4.0'
-    require_topology :replica_set
+    before(:all) do
+      case ClusterConfig.instance.topology
+      when :single
+        skip 'Transactions tests require a replica set (4.0+) or a sharded cluster (4.2+)'
+      when :replica_set
+        unless ClusterConfig.instance.server_version >= '4.0'
+          skip 'Transactions tests in a replica set topology require server 4.0+'
+        end
+      when :sharded
+        unless ClusterConfig.instance.server_version >= '4.2'
+          skip 'Transactions tests in a sharded cluster topology require server 4.2+'
+        end
+      else
+        raise NotImplementedError
+      end
+    end
   end
 
-  def require_scram_sha_256_support
-    before do
-      $mongo_server_features ||= begin
-        scanned_client_server!.features
+  def require_tls
+    before(:all) do
+      unless SpecConfig.instance.ssl?
+        skip "SSL not enabled"
       end
-      unless $mongo_server_features.scram_sha_256_enabled?
-        skip "SCRAM SHA 256 is not enabled on the server"
+    end
+  end
+
+  def require_no_tls
+    before(:all) do
+      if SpecConfig.instance.ssl?
+        skip "SSL enabled"
       end
     end
   end
 
-  def require_ssl
-    before do
-      unless SpecConfig.instance.ssl?
-        skip "SSL not enabled"
+  def require_local_tls
+    require_tls
+  end
+
+  def require_no_retry_writes
+    before(:all) do
+      if SpecConfig.instance.retry_writes?
+        skip "Retry writes is enabled"
+      end
+    end
+  end
+
+  def require_compression
+    before(:all) do
+      if SpecConfig.instance.compressors.nil?
+        skip "Compression is not enabled"
+      end
+    end
+  end
+
+  def require_no_compression
+    before(:all) do
+      if SpecConfig.instance.compressors
+        skip "Compression is enabled"
+      end
+    end
+  end
+
+  def ruby_version_gte(version)
+    before(:all) do
+      if RUBY_VERSION < version
+        skip "Ruby version #{version} or higher required"
+      end
+    end
+  end
+
+  def ruby_version_lt(version)
+    before(:all) do
+      if RUBY_VERSION >= version
+        skip "Ruby version less than #{version} required"
+      end
+    end
+  end
+
+  def require_auth
+    before(:all) do
+      unless ENV['AUTH'] == 'auth' || SpecConfig.instance.user || ClusterConfig.instance.auth_enabled?
+        skip "Auth required"
+      end
+    end
+  end
+
+  def require_no_auth
+    before(:all) do
+      if ENV['AUTH'] == 'auth' || SpecConfig.instance.user || ClusterConfig.instance.auth_enabled?
+        skip "Auth not allowed"
+      end
+    end
+  end
+
+  def require_no_x509_auth
+    before(:all) do
+      if SpecConfig.instance.x509_auth?
+        skip "X.509 auth not allowed"
+      end
+    end
+  end
+
+  # Can the driver specify a write concern that won't be overridden?
+  # (mongos 4.0+ overrides the write concern)
+  def require_set_write_concern
+    before(:all) do
+      if ClusterConfig.instance.topology == :sharded && ClusterConfig.instance.short_server_version >= '4.0'
+        skip "mongos 4.0+ overrides write concern"
+      end
+    end
+  end
+
+  def require_multi_shard
+    before(:all) do
+      if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length == 1
+        skip 'Test requires a minimum of two shards if run in sharded topology'
+      end
+    end
+  end
+
+  def require_no_multi_shard
+    before(:all) do
+      if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length > 1
+        skip 'Test requires a single shard if run in sharded topology'
+      end
+    end
+  end
+
+  def require_wired_tiger
+    before(:all) do
+      if ClusterConfig.instance.storage_engine != :wired_tiger
+        skip 'Test requires WiredTiger storage engine'
+      end
+    end
+  end
+
+  def require_wired_tiger_on_36
+    before(:all) do
+      if ClusterConfig.instance.short_server_version >= '3.6'
+        if ClusterConfig.instance.storage_engine != :wired_tiger
+          skip 'Test requires WiredTiger storage engine on 3.6+ servers'
+        end
+      end
+    end
+  end
+
+  def require_mmapv1
+    before(:all) do
+      if ClusterConfig.instance.storage_engine != :mmapv1
+        skip 'Test requires MMAPv1 storage engine'
+      end
+    end
+  end
+
+  def require_enterprise
+    before(:all) do
+      unless ClusterConfig.instance.enterprise?
+        skip 'Test requires enterprise build of MongoDB'
+      end
+    end
+  end
+
+  # Integration tests for SRV polling require internet connectivity to
+  # look up SRV records and a sharded cluster configured on default port on
+  # localhost (localhost:27017, localhost:27018).
+  def require_default_port_deployment
+    # Because the DNS records at test1.test.build.10gen.cc point to
+    # localhost:27017 & localhost:27018, the test suite must have been
+    # configured to use these addresses
+    before(:all) do
+      have_default_port = SpecConfig.instance.addresses.any? do |address|
+        %w(127.0.0.1 127.0.0.1:27017 localhost localhost:27017).include?(address)
+      end
+      unless have_default_port
+        skip 'This test requires the test suite to be configured for localhost:27017'
       end
     end
   end