mongoid-ultra 9.0.0.0.alpha1

data/spec/spec_helper.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'lite_spec_helper'
+
+MODELS = File.join(File.dirname(__FILE__), "support/models")
+$LOAD_PATH.unshift(MODELS)
+
+require "action_controller"
+require 'rspec/retry'
+
+if SpecConfig.instance.client_debug?
+  Mongoid.logger.level = Logger::DEBUG
+  Mongo::Logger.logger.level = Logger::DEBUG
+else
+  Mongoid.logger.level = Logger::INFO
+  Mongo::Logger.logger.level = Logger::INFO
+end
+
+# When testing locally we use the database named mongoid_test. However when
+# tests are running in parallel in a CI environment we need to use different
+# database names for each process running since we do not have transactions
+# and want a clean slate before each spec run.
+def database_id
+  "mongoid_test"
+end
+
+def database_id_alt
+  "mongoid_test_alt"
+end
+
+begin
+  require 'mrss/cluster_config'
+  require 'support/client_registry'
+  require 'mrss/constraints'
+  require 'mrss/event_subscriber'
+rescue LoadError => exc
+  raise LoadError.new <<~MSG.strip
+    The test suite requires shared tooling to be installed.
+    Please refer to spec/README.md for instructions.
+    #{exc.class}: #{exc}
+  MSG
+end
+
+ClusterConfig = Mrss::ClusterConfig
+
+require 'support/authorization'
+require 'support/expectations'
+require 'support/helpers'
+require 'support/macros'
+require 'support/constraints'
+require 'support/crypt'
+
+# Give MongoDB servers time to start up in CI environments
+if SpecConfig.instance.ci?
+  starting = true
+  client = Mongo::Client.new(SpecConfig.instance.addresses)
+  while starting
+    begin
+      client.command(ping: 1)
+      break
+    rescue Mongo::Error::OperationFailure => e
+      sleep(2)
+      client.cluster.scan!
+    end
+  end
+end
+
+CONFIG = {
+  clients: {
+    default: {
+      database: database_id,
+      hosts: SpecConfig.instance.addresses,
+      options: {
+        server_selection_timeout: 3.42,
+        wait_queue_timeout: 1,
+        max_pool_size: 5,
+        heartbeat_frequency: 180,
+        user: MONGOID_ROOT_USER.name,
+        password: MONGOID_ROOT_USER.password,
+        auth_source: Mongo::Database::ADMIN,
+      }
+    }
+  },
+  options: {
+    belongs_to_required_by_default: false,
+    log_level: if SpecConfig.instance.client_debug?
+      :debug
+    else
+      :info
+    end,
+  }
+}
+
+# Set the database that the spec suite connects to.
+Mongoid.configure do |config|
+  config.load_configuration(CONFIG)
+end
+
+# Autoload every model for the test suite that sits in spec/support/models.
+Dir[ File.join(MODELS, "*.rb") ].sort.each do |file|
+  name = File.basename(file, ".rb")
+  autoload name.camelize.to_sym, name
+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")
+end
+
+I18n.config.enforce_available_locales = false
+
+
+if %w(yes true 1).include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
+  require "i18n/backend/fallbacks"
+end
+
+# The user must be created before any of the tests are loaded, until
+# https://jira.mongodb.org/browse/MONGOID-4827 is implemented.
+client = Mongo::Client.new(SpecConfig.instance.addresses, server_selection_timeout: 3.03)
+begin
+  # Create the root user administrator as the first user to be added to the
+  # database. This user will need to be authenticated in order to add any
+  # more users to any other databases.
+  client.database.users.create(MONGOID_ROOT_USER)
+rescue Mongo::Error::OperationFailure => e
+ensure
+  client.close
+end
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+  config.include(Helpers)
+  config.include(Mongoid::Expectations)
+  config.extend(Mrss::Constraints)
+  config.extend(Constraints)
+  config.extend(Mongoid::Macros)
+
+  config.before(:suite) do
+    Mongoid.purge!
+  end
+
+  # Drop all collections and clear the identity map before each spec.
+  config.before(:each) do
+    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|
+      coll.delete_many
+    end
+  end
+end
+
+# A subscriber to be used with the Ruby driver for testing.
+class EventSubscriber
+
+  # The started events.
+  attr_reader :started_events
+
+  # The succeeded events.
+  attr_reader :succeeded_events
+
+  # The failed events.
+  attr_reader :failed_events
+
+  # Create the test event subscriber.
+  #
+  # @example Create the subscriber
+  #   EventSubscriber.new
+  def initialize
+    @started_events = []
+    @succeeded_events = []
+    @failed_events = []
+  end
+
+  # Cache the succeeded event.
+  #
+  # @param [ Event ] event The event.
+  def succeeded(event)
+    @succeeded_events.push(event)
+  end
+
+  # Cache the started event.
+  #
+  # @param [ Event ] event The event.
+  def started(event)
+    @started_events.push(event)
+  end
+
+  # Cache the failed event.
+  #
+  # @param [ Event ] event The event.
+  def failed(event)
+    @failed_events.push(event)
+  end
+
+  # Clear all cached events.
+  def clear_events!
+    @started_events = []
+    @succeeded_events = []
+    @failed_events = []
+  end
+end

data/spec/support/authorization.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Set up a root user so we can set up authentication on a database level.
+MONGOID_ROOT_USER = Mongo::Auth::User.new(
+  database: Mongo::Database::ADMIN,
+  user: 'mongoid-user',
+  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_MONITOR
+  ]
+)

data/spec/support/client_registry.rb

@@ -0,0 +1,9 @@
+require 'singleton'
+
+class ClientRegistry
+  include Singleton
+
+  def global_client(name)
+    Mongoid.default_client
+  end
+end

data/spec/support/constraints.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Constraints
+  RAILS_VERSION = ActiveSupport.version.to_s.split('.')[0..1].join('.').freeze
+
+  def min_driver_version(version)
+    required_version = version.split('.').map(&:to_i)
+    actual_version = driver_version(required_version.length)
+    before(:all) do
+      if (actual_version <=> required_version) < 0
+        skip "Driver version #{version} or higher is required"
+      end
+    end
+  end
+
+  def max_driver_version(version)
+    required_version = version.split('.').map(&:to_i)
+    actual_version = driver_version(required_version.length)
+    before(:all) do
+      if (actual_version <=> required_version) > 0
+        skip "Driver version #{version} or lower is required"
+      end
+    end
+  end
+
+  def driver_version(precision)
+    Mongo::VERSION.split('.')[0...precision].map(&:to_i)
+  end
+
+  def min_bson_version(version)
+    required_version = version.split('.').map(&:to_i)
+    actual_version = bson_version(required_version.length)
+    before(:all) do
+      if (actual_version <=> required_version) < 0
+        skip "bson-ruby version #{version} or higher is required"
+      end
+    end
+  end
+
+  def max_bson_version(version)
+    required_version = version.split('.').map(&:to_i)
+    actual_version = bson_version(required_version.length)
+    before(:all) do
+      if (actual_version <=> required_version) > 0
+        skip "bson-ruby version #{version} or lower is required"
+      end
+    end
+  end
+
+  def bson_version(precision)
+    BSON::VERSION.split('.')[0...precision].map(&:to_i)
+  end
+
+  def min_rails_version(version)
+    unless version =~ /\A\d+\.\d+\z/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
+    end
+
+    before(:all) 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 =~ /\A\d+\.\d+\z/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
+    end
+
+    before(:all) do
+      if version < RAILS_VERSION
+        skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
+      end
+    end
+  end
+end

data/spec/support/crypt/models.rb

@@ -0,0 +1,43 @@
+module Crypt
+  class Patient
+    include Mongoid::Document
+
+    encrypt_with key_id: "grolrnFVSSW9Gq04Q87R9Q=="
+
+    field :code, type: String
+    field :medical_records, type: Array, encrypt: { deterministic: false}
+    field :blood_type, type: String, encrypt: { deterministic: false }
+    field :ssn, type: Integer, encrypt: { deterministic: true }
+
+    embeds_one :insurance, class_name: "Crypt::Insurance"
+  end
+
+  class Insurance
+    include Mongoid::Document
+
+    field :policy_number, type: Integer, encrypt: { deterministic: true }
+    embedded_in :patient, class_name: "Crypt::Patient"
+  end
+
+  class User
+    include Mongoid::Document
+
+    field :name, type: String, encrypt: {
+      key_id: "grolrnFVSSW9Gq04Q87R9Q==",
+      deterministic: false
+    }
+    field :email, type: String, encrypt: {
+      key_id: "S34mE/HhSFSym3yErpER6Q==",
+      deterministic: true
+    }
+  end
+
+  class Car
+    include Mongoid::Document
+
+    encrypt_with key_id: "grolrnFVSSW9Gq04Q87R9Q==", deterministic: true
+
+    field :vin, type: String, encrypt: true
+    field :make, type: String
+  end
+end

data/spec/support/crypt.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Mongoid
+  # This module includes helpers for testing encryption.
+  module Crypt
+
+    shared_context 'with encryption' do
+      let(:mongocryptd_port) do
+        if ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'] &&
+          !ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'].empty?
+        then
+          ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'].to_i
+        else
+          27020
+        end
+      end
+
+      let(:extra_options) do
+        {
+          mongocryptd_spawn_args: ["--port=#{mongocryptd_port}"],
+          mongocryptd_uri: "mongodb://localhost:#{mongocryptd_port}",
+        }
+      end
+
+      let(:crypt_shared_lib_path) do
+        ENV['MONGO_RUBY_DRIVER_CRYPT_SHARED_LIB_PATH']
+      end
+
+      let(:key_vault_client) do
+        Mongo::Client.new(SpecConfig.instance.addresses, database: key_vault_database)
+      end
+
+      let(:key_vault_database) do
+        'encryption'
+      end
+
+      let(:key_vault_collection) do
+        '__keyVault'
+      end
+
+      let(:key_vault_namespace) do
+        "#{key_vault_database}.#{key_vault_collection}"
+      end
+
+      let(:local_master_key) do
+        'A' * 96
+      end
+
+      let(:kms_providers) do
+        {
+          local: {
+            key: local_master_key
+          }
+        }
+      end
+
+      let(:key_alt_name) do
+        'mongoid_test_key'
+      end
+
+      let(:client_encryption) do
+        Mongo::ClientEncryption.new(
+          key_vault_client,
+          key_vault_namespace: key_vault_namespace,
+          kms_providers: kms_providers
+        )
+      end
+
+      let(:data_key_id) do
+        if (data_key = client_encryption.get_key_by_alt_name(key_alt_name))
+          Base64.encode64(data_key['_id'].data)
+        else
+          key_id = client_encryption.create_data_key('local', key_alt_name: key_alt_name)
+          Base64.encode64(key_id.data).strip
+        end
+      end
+    end
+  end
+end

data/spec/support/expectations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Expectations
+
+    def connection_class
+      if defined?(Mongo::Server::ConnectionBase)
+        Mongo::Server::ConnectionBase
+      else
+        # Pre-2.8 drivers
+        Mongo::Server::Connection
+      end
+    end
+
+    def expect_query(number)
+      rv = nil
+      RSpec::Mocks.with_temporary_scope do
+        if number > 0
+          expect_any_instance_of(connection_class).to receive(:command_started).exactly(number).times.and_call_original
+        else
+          expect_any_instance_of(connection_class).not_to receive(:command_started)
+        end
+        rv = yield
+      end
+      rv
+    end
+
+    def expect_no_queries(&block)
+      expect_query(0, &block)
+    end
+  end
+end

data/spec/support/feature_sandbox.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# A helper utility for allowing features to be loaded and constants defined
+# inside a sandbox, where they can be unloaded and undefined when finished.
+#
+# @example Quarantining a block of code.
+#   FeatureSandbox.quarantine do
+#      require "support/rails_mock"
+#      expect(defined?(Rails)).to be == "constant"
+#   end
+#   expect(defined?(Rails)).to be_nil
+module FeatureSandbox
+  extend self
+
+  # Initiates the quarantine by noting the current state of the top-level
+  # constants, the $LOADED_FEATURES array, and the $LOAD_PATH.
+  #
+  # @return Hash The current state of the environment.
+  def start_quarantine
+    { constants: Object.constants.dup,
+      features: $LOADED_FEATURES.dup,
+      load_path: $LOAD_PATH.dup }
+  end
+
+  # Terminates the quarantine indicated by the given state, by rolling back
+  # changes made since the state was created.
+  #
+  # @param [ Hash ] state The state object to roll the environment back to.
+  def end_quarantine(state)
+    restore_load_path(state[:load_path])
+    unload_features($LOADED_FEATURES - state[:features])
+    unload_constants(Object, Object.constants - state[:constants])
+  end
+
+  # A convenience method for starting a quarantine, yielding to a block, and
+  # then ending the quarantine when the block finishes.
+  #
+  # @yield The block will be executed within the quarantine, with all changes
+  #    to state rolled back upon completion.
+  def quarantine
+    state = start_quarantine
+    yield
+  ensure
+    end_quarantine(state)
+  end
+
+  private
+
+  def restore_load_path(list)
+    $LOAD_PATH.replace(list)
+  end
+
+  def unload_features(list)
+    list.each do |path|
+      $LOADED_FEATURES.delete(path)
+    end
+  end
+
+  def unload_constants(parent, list)
+    list.each do |name|
+      obj = parent.const_get(name)
+      if obj.is_a?(Module) && obj.constants(false).any?
+        unload_constants(obj, obj.constants(false))
+      end
+
+      Mongoid.deregister_model(obj) if obj.is_a?(Mongoid::Document)
+
+      parent.send(:remove_const, name)
+    end
+  end
+end

data/spec/support/helpers.rb

@@ -0,0 +1,11 @@
+module Helpers
+  # Reloads the specified model class.
+  #
+  # @param [ String | Symbol ] name Class name to reload.
+  def reload_model(name)
+    Object.class_eval do
+      remove_const(name)
+    end
+    load "spec/support/models/#{name.to_s.underscore}.rb"
+  end
+end

data/spec/support/immutable_ids.rb

@@ -0,0 +1,118 @@
+module Mongoid
+  module ImmutableIds
+    def immutable_id_examples_as(name)
+      shared_examples_for name do
+        shared_examples 'a persisted document' do
+          it 'should disallow _id to be updated' do
+            expect { invoke_operation! }
+              .to raise_error(Mongoid::Errors::ImmutableAttribute)
+          end
+    
+          context 'when immutable_ids is false' do
+            before { Mongoid::Config.immutable_ids = false }
+            after { Mongoid::Config.immutable_ids = true }
+
+            it 'should ignore the change and issue a warning' do
+              expect(Mongoid::Warnings).to receive(:warn_mutable_ids)
+              expect { invoke_operation! }.not_to raise_error
+              expect(id_is_unchanged).not_to be legacy_behavior_expects_id_to_change
+            end
+          end
+
+          context 'when id is set to the existing value' do
+            let(:new_id_value) { object._id }
+
+            it 'should allow the update to proceed' do
+              expect { invoke_operation! }
+                .not_to raise_error
+            end
+          end
+        end
+
+        context 'when the field is _id' do
+          let(:new_id_value) { 1234 }
+
+          context 'when the document is top-level' do    
+            let(:legacy_behavior_expects_id_to_change) { false }
+
+            context 'when the document is new' do
+              let(:object) { Person.new }
+    
+              it 'should allow _id to be updated' do
+                invoke_operation!
+                expect(object.new_record?).to be false
+                expect(object.reload._id).to be == new_id_value
+              end
+            end
+    
+            context 'when the document has been persisted' do
+              let(:object) { Person.create }
+              let!(:original_id) { object._id }
+              let(:id_is_unchanged) { Person.exists?(original_id) }
+    
+              it_behaves_like 'a persisted document'
+            end
+          end
+    
+          context 'when the document is embedded' do
+            let(:parent) { Person.create }
+            let(:legacy_behavior_expects_id_to_change) { true }
+
+            context 'when the document is new' do
+              let(:object) { parent.favorites.new }
+    
+              it 'should allow _id to be updated' do
+                invoke_operation!
+                expect(object.new_record?).to be false
+                expect(parent.reload.favorites.first._id).to be == new_id_value
+              end
+            end
+    
+            context 'when the document has been persisted' do
+              let(:object) { parent.favorites.create }
+              let!(:original_id) { object._id }
+              let(:id_is_unchanged) { parent.favorites.where(_id: original_id).exists? }
+      
+              it_behaves_like 'a persisted document'
+
+              context 'updating embeds_one via parent' do
+                context 'when immutable_ids is false' do
+                  before { Mongoid::Config.immutable_ids = false }
+                  after { Mongoid::Config.immutable_ids = true }
+
+                  it 'should ignore the change' do
+                    expect(Mongoid::Warnings).to receive(:warn_mutable_ids)
+
+                    parent.pet = pet = Pet.new
+                    parent.save
+
+                    original_id = pet._id
+                    new_id = BSON::ObjectId.new
+
+                    expect { parent.update(pet: { _id: new_id }) }.not_to raise_error
+                    expect(parent.reload.pet._id.to_s).to be == original_id.to_s
+                  end
+                end
+
+                context 'when immutable_ids is true' do
+                  before { expect(Mongoid::Config.immutable_ids).to be true }
+
+                  it 'should raise an exception' do
+                    parent.pet = pet = Pet.new
+                    parent.save
+
+                    original_id = pet._id
+                    new_id = BSON::ObjectId.new
+
+                    expect { parent.update(pet: { _id: new_id }) }
+                      .to raise_error(Mongoid::Errors::ImmutableAttribute)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end