mongoid 5.4.0 → 6.4.8

data/spec/mongoid/validatable/presence_spec.rb

@@ -280,7 +280,7 @@ describe Mongoid::Validatable::PresenceValidator do
             end
 
             it "does not save the relation" do
-              expect { game.reload }.to raise_error
+              expect { game.reload }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
         end

data/spec/mongoid/validatable/uniqueness_spec.rb

@@ -19,34 +19,41 @@ describe Mongoid::Validatable::UniquenessValidator do
         context "when persisting to another collection" do
 
           before do
-            Dictionary.with(collection: "dicts").create(name: "websters")
+            Dictionary.with(collection: "dicts") do |klass|
+              klass.create(name: "websters")
+            end
           end
 
           context "when the document is not valid" do
 
             let(:websters) do
-              Dictionary.with(collection: "dicts").new(name: "websters")
+              object = nil
+              valid = Dictionary.with(collection: "dicts") do |klass|
+                object = klass.new(name: "websters")
+                object.valid?
+              end
+              { :valid => valid, :object => object }
             end
 
             it "performs the validation on the correct collection" do
-              expect(websters).to_not be_valid
+              expect(websters[:valid]).to be(false)
             end
 
             it "adds the uniqueness error" do
-              websters.valid?
-              expect(websters.errors[:name]).to_not be_nil
+              expect(websters[:object].errors[:name]).to_not be_nil
             end
 
             it "clears the persistence options in the thread local" do
-              websters.valid?
-              expect(Dictionary.persistence_options).to be_nil
+              expect(Dictionary.persistence_context).to eq(Mongoid::PersistenceContext.new(Dictionary))
             end
           end
 
           context "when the document is valid" do
 
             let(:oxford) do
-              Dictionary.with(collection: "dicts").new(name: "oxford")
+              Dictionary.with(collection: "dicts") do |klass|
+                klass.new(name: "oxford")
+              end
             end
 
             it "performs the validation on the correct collection" do
@@ -2417,6 +2424,7 @@ describe Mongoid::Validatable::UniquenessValidator do
 
     before do
       Person.validates_uniqueness_of(:username)
+      Person.index({ ssn: 1 }, { unique: true })
       Person.create_indexes
     end
 
@@ -2426,12 +2434,13 @@ describe Mongoid::Validatable::UniquenessValidator do
 
     after do
       Person.reset_callbacks(:validate)
+      Person.collection.drop
     end
 
     it "transfers the options to the cloned client" do
       expect {
         Person.create!(ssn: "132-11-1111", username: "asdfsdfA")
-      }.to raise_error
+      }.to raise_error(Mongo::Error::OperationFailure)
     end
   end
 end

data/spec/mongoid/validatable_spec.rb

@@ -69,6 +69,22 @@ describe Mongoid::Validatable do
       it "uses the provided context" do
         expect(account).to be_valid(:update)
       end
+
+      context 'when multiple contexts are provided' do
+
+        let(:princess) do
+          Princess.new
+        end
+
+        let(:validation) do
+          princess.valid?([:create, :update])
+        end
+
+        it 'validates using each context' do
+          expect(validation).to be(false)
+          expect(princess.errors.messages.keys).to eq([:color, :name])
+        end
+      end
     end
 
     context "when not provided a context" do

data/spec/rails/controller_extension/controller_runtime_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+require "mongoid/railties/controller_runtime"
+
+describe "Mongoid::Railties::ControllerRuntime" do
+  controller_runtime = Mongoid::Railties::ControllerRuntime
+  collector = controller_runtime::Collector
+
+  def set_metric value
+    Thread.current["Mongoid.controller_runtime"] = value
+  end
+
+  def clear_metric!
+    set_metric 0
+  end
+
+  describe "Collector" do
+
+    it "stores the metric in thread-safe manner" do
+      clear_metric!
+      expect(collector.runtime).to eq(0)
+      set_metric 42
+      expect(collector.runtime).to eq(42)
+    end
+
+    it "sets metric on both succeeded and failed" do
+      instance = collector.new
+      event_payload = OpenStruct.new duration: 42
+
+      clear_metric!
+      instance.succeeded event_payload
+      expect(collector.runtime).to eq(42)
+
+      clear_metric!
+      instance.failed event_payload
+      expect(collector.runtime).to eq(42)
+    end
+
+    it "resets the metric and returns the value" do
+      clear_metric!
+      expect(collector.reset_runtime).to eq(0)
+      set_metric 42
+      expect(collector.reset_runtime).to eq(42)
+      expect(collector.runtime).to eq(0)
+    end
+
+  end
+
+  reference_controller_class = Class.new do
+    def process_action *_
+      @process_action = true
+    end
+
+    def cleanup_view_runtime *_
+      @cleanup_view_runtime.call
+    end
+
+    def append_info_to_payload *_
+      @append_info_to_payload = true
+    end
+
+    def self.log_process_action *_
+      @log_process_action.call
+    end
+  end
+
+  controller_class = Class.new reference_controller_class do
+    include controller_runtime::ControllerExtension
+  end
+
+  let(:controller){ controller_class.new }
+
+  it "resets the metric before each action" do
+    set_metric 42
+    controller.send(:process_action, 'foo')
+    expect(collector.runtime).to be(0)
+    expect(controller.instance_variable_get "@process_action").to be(true)
+  end
+
+  it "strips the metric of other sources of the runtime" do
+    set_metric 1
+    controller.instance_variable_set "@cleanup_view_runtime", ->{
+      controller.instance_variable_set "@cleanup_view_runtime", true
+      set_metric 13
+      42
+    }
+    returned = controller.send :cleanup_view_runtime
+    expect(controller.instance_variable_get "@cleanup_view_runtime").to be(true)
+    expect(controller.mongoid_runtime).to eq(14)
+    expect(returned).to be(29)
+  end
+
+  it "appends the metric to payload" do
+    payload = {}
+    set_metric 42
+    controller.send :append_info_to_payload, payload
+    expect(controller.instance_variable_get "@append_info_to_payload").to be(true)
+    expect(payload[:mongoid_runtime]).to eq(42)
+  end
+
+  it "adds metric to log message" do
+    controller_class.instance_variable_set "@log_process_action", ->{
+      controller_class.instance_variable_set "@log_process_action", true
+      []
+    }
+    messages = controller_class.log_process_action mongoid_runtime: 42.101
+    expect(controller_class.instance_variable_get "@log_process_action").to be(true)
+    expect(messages).to eq(["MongoDB: 42.1ms"])
+  end
+
+end

data/spec/spec_helper.rb

@@ -34,9 +34,14 @@ end
 
 require 'support/authorization'
 require 'support/expectations'
+require 'support/macros'
+require 'support/spec_config'
+require 'support/cluster_config'
+require 'support/constraints'
+require 'support/session_registry'
 
 # Give MongoDB time to start up on the travis ci environment.
-if (ENV['CI'] == 'travis')
+if (ENV['CI'] == 'travis' || ENV['CI'] == 'evergreen')
   starting = true
   client = Mongo::Client.new(['127.0.0.1:27017'])
   while starting
@@ -64,6 +69,9 @@ CONFIG = {
         auth_source: Mongo::Database::ADMIN,
       }
     }
+  },
+  options: {
+    belongs_to_required_by_default: false
   }
 }
 
@@ -71,24 +79,29 @@ 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 testing_locally?
   !(ENV['CI'] == 'travis')
 end
 
-def testing_replica_set?
-  Mongoid::Clients.default.cluster.replica_set?
+def array_filters_supported?
+  Mongoid::Clients.default.cluster.next_primary.features.array_filters_enabled?
 end
+alias :sessions_supported? :array_filters_supported?
 
 # Set the database that the spec suite connects to.
 Mongoid.configure do |config|
   config.load_configuration(CONFIG)
 end
 
-def collation_supported?
-  Mongoid::Clients.default.cluster.next_primary.features.collation_enabled?
-end
-alias :decimal128_supported? :collation_supported?
-
 # Autoload every model for the test suite that sits in spec/app/models.
 Dir[ File.join(MODELS, "*.rb") ].sort.each do |file|
   name = File.basename(file, ".rb")
@@ -105,6 +118,12 @@ module MyApp
   end
 end
 
+module Mongoid
+  class Query
+    include Mongoid::Criteria::Queryable
+  end
+end
+
 ActiveSupport::Inflector.inflections do |inflect|
   inflect.irregular("canvas", "canvases")
   inflect.singular("address_components", "address_component")
@@ -113,8 +132,13 @@ end
 I18n.config.enforce_available_locales = false
 
 RSpec.configure do |config|
+  config.expect_with(:rspec) do |c|
+    c.syntax = [:should, :expect]
+  end
+
   config.raise_errors_for_deprecations!
   config.include(Mongoid::Expectations)
+  config.extend(Constraints)
 
   config.before(:suite) do
     client = Mongo::Client.new(["#{HOST}:#{PORT}"])
@@ -132,3 +156,72 @@ RSpec.configure do |config|
     Mongoid.purge!
   end
 end
+
+# A subscriber to be used with the Ruby driver for testing.
+#
+# @since 6.4.0
+class EventSubscriber
+
+  # The started events.
+  #
+  # @since 6.4.0
+  attr_reader :started_events
+
+  # The succeeded events.
+  #
+  # @since 6.4.0
+  attr_reader :succeeded_events
+
+  # The failed events.
+  #
+  # @since 6.4.0
+  attr_reader :failed_events
+
+  # Create the test event subscriber.
+  #
+  # @example Create the subscriber
+  #   EventSubscriber.new
+  #
+  # @since 6.4.0
+  def initialize
+    @started_events = []
+    @succeeded_events = []
+    @failed_events = []
+  end
+
+  # Cache the succeeded event.
+  #
+  # @param [ Event ] event The event.
+  #
+  # @since 6.4.0
+  def succeeded(event)
+    @succeeded_events.push(event)
+  end
+
+  # Cache the started event.
+  #
+  # @param [ Event ] event The event.
+  #
+  # @since 6.4.0
+  def started(event)
+    @started_events.push(event)
+  end
+
+  # Cache the failed event.
+  #
+  # @param [ Event ] event The event.
+  #
+  # @since 6.4.0
+  def failed(event)
+    @failed_events.push(event)
+  end
+
+  # Clear all cached events.
+  #
+  # @since 6.4.0
+  def clear_events!
+    @started_events = []
+    @succeeded_events = []
+    @failed_events = []
+  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(/^.*\//, '').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(/^_/, '')
+      if topology =~ /^replica_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

@@ -0,0 +1,101 @@
+module Constraints
+  RAILS_VERSION = ActiveSupport.version.to_s.split('.')[0..1].join('.').freeze
+
+  def min_rails_version(version)
+    unless version =~ /^\d+\.\d+$/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
+    end
+
+    before do
+      if version > RAILS_VERSION
+        skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}"
+      end
+    end
+  end
+
+  def max_rails_version(version)
+    unless version =~ /^\d+\.\d+$/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
+    end
+
+    before do
+      if version < RAILS_VERSION
+        skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
+      end
+    end
+  end
+
+  def min_server_version(version)
+    unless version =~ /^\d+\.\d+$/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
+    end
+
+    before do
+      if version > ClusterConfig.instance.server_version
+        skip "Server version #{version} or higher required, we have #{ClusterConfig.instance.server_version}"
+      end
+    end
+  end
+
+  def max_server_version(version)
+    unless version =~ /^\d+\.\d+$/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
+    end
+
+    before do
+      if version < ClusterConfig.instance.short_server_version
+        skip "Server version #{version} or lower required, we have #{ClusterConfig.instance.server_version}"
+      end
+    end
+  end
+
+  def require_topology(*topologies)
+    topologies = topologies.map { |t| t.to_s }
+    invalid_topologies = topologies - %w(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)
+        skip "Topology #{topologies.join(' or ')} required, we have #{topology}"
+      end
+    end
+  end
+
+  def max_example_run_time(timeout)
+    around do |example|
+      TimeoutInterrupt.timeout(timeout) do
+        example.run
+      end
+    end
+  end
+
+  def require_transaction_support
+    min_server_version '4.0'
+    require_topology :replica_set
+  end
+
+  def require_scram_sha_256_support
+    before do
+      $mongo_server_features ||= begin
+        scanned_client_server!.features
+      end
+      unless $mongo_server_features.scram_sha_256_enabled?
+        skip "SCRAM SHA 256 is not enabled on the server"
+      end
+    end
+  end
+
+  def require_ssl
+    before do
+      unless SpecConfig.instance.ssl?
+        skip "SSL not enabled"
+      end
+    end
+  end
+end

data/spec/support/macros.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Macros
+    def use_spec_mongoid_config
+      around do |example|
+        config_path = File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+
+        Mongoid::Clients.clear
+        Mongoid.load!(config_path, :test)
+
+        begin
+          example.run
+        ensure
+          Mongoid::Config.reset
+        end
+      end
+    end
+  end
+end

data/spec/support/session_registry.rb

@@ -0,0 +1,50 @@
+require 'singleton'
+
+module Mongo
+  class Client
+    alias :get_session_without_tracking :get_session
+
+    def get_session(options = {})
+      get_session_without_tracking(options).tap do |session|
+        SessionRegistry.instance.register(session)
+      end
+    end
+  end
+
+  class Session
+    alias :end_session_without_tracking :end_session
+
+    def end_session
+      SessionRegistry.instance.unregister(self)
+      end_session_without_tracking
+    end
+  end
+end
+
+
+class SessionRegistry
+  include Singleton
+
+  def initialize
+    @registry = {}
+  end
+
+  def register(session)
+    @registry[session.session_id] = session if session
+  end
+
+  def unregister(session)
+    @registry.delete(session.session_id)
+  end
+
+  def verify_sessions_ended!
+    unless @registry.empty?
+      sessions = @registry.map { |_, session| session }
+      raise "Session registry contains live sessions: #{sessions.join(', ')}"
+    end
+  end
+
+  def clear_registry
+    @registry = {}
+  end
+end