mongoid 6.4.8 → 7.0.0.beta

data/spec/mongoid/relations/options_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Options do
-
-  describe ".validate!" do
-
-    let(:relation) do
-      Mongoid::Relations::Embedded::Many
-    end
-
-    context "when the options are valid for the relation" do
-
-      let(:options) do
-        { relation: relation, as: :addressable }
-      end
-
-      it "returns true" do
-        expect(described_class.validate!(options)).to be true
-      end
-    end
-
-    context "when the options are invalid for the relation" do
-
-      let(:options) do
-        { name: :addresses, relation: relation, polymorphic: true }
-      end
-
-      it "raises an error" do
-        expect {
-          described_class.validate!(options)
-        }.to raise_error(Mongoid::Errors::InvalidOptions)
-      end
-    end
-  end
-end

data/spec/rails/controller_extension/controller_runtime_spec.rb

@@ -1,110 +0,0 @@
-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/support/cluster_config.rb

@@ -1,158 +0,0 @@
-# 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

@@ -1,101 +0,0 @@
-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

@@ -1,20 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-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