mongoid 7.0.2 → 8.1.1

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -3,7 +3,11 @@ development:
   clients:
     # Defines the default client. (required)
     default:
-      # Defines the name of the default database that Mongoid can connect to.
+      # Mongoid can connect to a URI accepted by the driver:
+      # uri: mongodb://user:password@mongodb.domain.com:27017/<%= database_name || app_name %>_development
+
+      # Otherwise define the parameters separately.
+      # This defines the name of the default database that Mongoid can connect to.
       # (required).
       database: <%= database_name || app_name %>_development
       # Provides the hosts the default client can connect to. Must be an array
@@ -53,7 +57,7 @@ development:
         # connect: :direct
 
         # Changes the default time in seconds the server monitors refresh their status
-        # via ismaster commands. (default: 10)
+        # via hello commands. (default: 10)
         # heartbeat_frequency: 10
 
         # The time in seconds for selecting servers for a near read preference. (default: 0.015)
@@ -73,11 +77,16 @@ development:
         # wait_queue_timeout: 5
 
         # The time to wait to establish a connection before timing out, in seconds.
-        # (default: 5)
-        # connect_timeout: 5
-
-        # The timeout to wait to execute operations on a socket before raising an error.
-        # (default: 5)
+        # (default: 10)
+        # connect_timeout: 10
+
+        # How long to wait for a response for each operation sent to the
+        # server. This timeout should be set to a value larger than the
+        # processing time for the longest operation that will be executed
+        # by the application. Note that this is a client-side timeout;
+        # the server may continue executing an operation after the client
+        # aborts it with the SocketTimeout exception.
+        # (default: nil, meaning no timeout)
         # socket_timeout: 5
 
         # The name of the replica set to connect to. Servers provided as seeds that do
@@ -98,22 +107,46 @@ development:
         # A passphrase for the private key.
         # ssl_key_pass_phrase: password
 
-        # Whether or not to do peer certification validation. (default: true)
+        # Whether to do peer certification validation. (default: true)
         # ssl_verify: true
 
-        # The file containing a set of concatenated certification authority certifications
+        # The file containing concatenated certificate authority certificates
         # used to validate certs passed from the other end of the connection.
         # ssl_ca_cert: /path/to/ca.cert
-
+        
+        # Whether to truncate long log lines. (default: true)
+        # truncate_logs: true
 
   # Configure Mongoid specific options. (optional)
   options:
-    # Includes the root model name in json serialization. (default: false)
+    # Application name that is printed to the mongodb logs upon establishing
+    # a connection in server versions >= 3.4. Note that the name cannot
+    # exceed 128 bytes. It is also used as the database name if the
+    # database name is not explicitly defined. (default: nil)
+    # app_name: MyApplicationName
+    
+    # Mark belongs_to associations as required by default, so that saving a
+    # model with a missing belongs_to association will trigger a validation
+    # error. (default: true)
+    # belongs_to_required_by_default: true
+    
+    # Raise an exception when a field is redefined. (default: false)
+    # duplicate_fields_exception: false
+    
+    # Include the root model name in json serialization. (default: false)
     # include_root_in_json: false
 
     # Include the _type field in serialization. (default: false)
     # include_type_for_serialization: false
 
+    # Whether to join nested persistence contexts for atomic operations
+    # to parent contexts by default. (default: false)
+    # join_contexts: false
+
+    # Set the Mongoid and Ruby driver log levels when Mongoid is not using
+    # Ruby on Rails logger instance. (default: :info)
+    # log_level: :info
+    
     # Preload all models in development, needed when models use
     # inheritance. (default: false)
     # preload_models: false
@@ -126,32 +159,20 @@ development:
     # existing method. (default: false)
     # scope_overwrite_exception: false
 
-    # Raise an error when defining a field with the same name as an
-    # existing method. (default: false)
-    # duplicate_fields_exception: false
-
-    # Use Active Support's time zone in conversions. (default: true)
+    # Use ActiveSupport's time zone in time operations instead of
+    # the Ruby default time zone. See the time zone section below for
+    # further information. (default: true)
     # use_activesupport_time_zone: true
 
-    # Ensure all times are UTC in the app side. (default: false)
+    # Return stored times as UTC. See the time zone section below for
+    # further information. Most applications should not use this option.
+    # (default: false)
     # use_utc: false
 
-    # Set the Mongoid and Ruby driver log levels when not in a Rails
-    # environment. The Mongoid logger will be set to the Rails logger
-    # otherwise.(default: :info)
-    # log_level: :info
-
-    # Control whether `belongs_to` association is required. By default
-    # `belongs_to` will trigger a validation error if the association
-    # is not present. (default: true)
-    # belongs_to_required_by_default: true
-
-    # Application name that is printed to the mongodb logs upon establishing a
-    # connection in server versions >= 3.4. Note that the name cannot exceed 128 bytes.
-    # app_name: MyApplicationName
-
-    # Use background indexes by default if `background` option not specified. (default: false)
+    # (Deprecated) In MongoDB 4.0 and earlier, set whether to create
+    # indexes in the background by default. (default: false)
     # background_indexing: false
+
 test:
   clients:
     default:

data/lib/rails/generators/mongoid/model/model_generator.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require "rails/generators/mongoid_generator"
 
 module Mongoid
@@ -10,7 +11,7 @@ module Mongoid
 
       check_class_collision
 
-      class_option :timestamps, type: :boolean
+      class_option :timestamps, type: :boolean, default: true
       class_option :parent,     type: :string, desc: "The parent class for the generated model"
       class_option :collection, type: :string, desc: "The collection for storing model's documents"
 

data/lib/rails/generators/mongoid/model/templates/model.rb.tt

@@ -13,7 +13,7 @@ class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent]
   field :<%= attribute.name %>, type: <%= attribute.type_class %>
 <% end -%>
 <% attributes.select{|attr| attr.reference? }.each do |attribute| -%>
-  embedded_in :<%= attribute.name%>
+  belongs_to :<%= attribute.name%>
 <% end -%>
 end
 <% end -%>

data/lib/rails/generators/mongoid_generator.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require "rails/generators/named_base"
 require "rails/generators/active_model"
 

data/lib/rails/mongoid.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Rails
   module Mongoid
     extend self
@@ -40,16 +41,14 @@ module Rails
     # method as a convenience.
     #
     # @example Load the model.
-    #   Mongoid.load_model("/mongoid/behaviour")
+    #   Mongoid.load_model("/mongoid/behavior")
     #
     # @param [ String ] file The base filename.
-    #
-    # @since 2.0.0.rc.3
     def load_model(file)
       begin
         require_dependency(file)
       rescue Exception => e
-        Logger.new($stdout).warn(e.message)
+        Logger.new(STDERR).warn(e.message)
       end
     end
   end

data/spec/README.md

@@ -0,0 +1,33 @@
+# Running Mongoid Tests
+
+## Quick Start
+
+The test suite requires shared tooling that is stored in a separate repository
+and is referenced as a submodule. After checking out the desired driver
+branch, check out the matching submodules:
+
+    git submodule init
+    git submodule update
+
+Spin up a MongoDB deployment against which to run the Mongoid specs.
+Mongoid specs support a variety of MongoDB topologies, but the simplest is
+a single MongoDB instance:
+
+    # Launch mongod in one terminal
+    mkdir /tmp/mdb
+    mongod --dbpath /tmp/mdb
+
+Run the test suite in a separate terminal:
+
+    rake
+
+
+## Caveats
+
+### "Too many open files" error
+
+On MacOS, you may encounter a "Too many open files" error on the MongoDB server
+when running the tests. If this happens, stop the server, run the command
+`ulimit -n 10000` in the same terminal session as the server, and restart
+the server. This will increase the number of files that can be opened.
+Then, re-run the tests.

data/spec/config/mongoid.yml

@@ -3,7 +3,9 @@ test:
     default:
       database: mongoid_test
       hosts:
-        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+        <% SpecConfig.instance.addresses.each do |address| %>
+          - <%= address %>
+        <% end %>
       options:
         user: "mongoid-user"
         password: "password"
@@ -13,14 +15,18 @@ test:
           tag_sets:
             - use: web
         max_pool_size: 1
+        server_selection_timeout: 3.14
     reports:
       database: reports
       hosts:
-        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+        <% SpecConfig.instance.addresses.each do |address| %>
+          - <%= address %>
+        <% end %>
       options:
         user: "mongoid-user"
         password: "password"
         auth_source: "admin"
+        server_selection_timeout: 3.14
   options:
     include_root_in_json: false
     include_type_for_serialization: false
@@ -33,13 +39,33 @@ test:
     belongs_to_required_by_default: false
     app_name: 'testing'
     background_indexing: false
+    join_contexts: false
+  driver_options:
+    broken_view_options: false
+    # Don't set validate_update_replace here, as it is used to check if the
+    # default driver options are kept in Mongoid.
+test_nil:
+  clients:
+    default:
+      database: mongoid_test
+      hosts:
+        <% SpecConfig.instance.addresses.each do |address| %>
+          - <%= address %>
+        <% end %>
+  driver_options:
+    broken_view_options:
+    validate_update_replace: false
+
 test_with_max_staleness:
   clients:
     default:
       database: mongoid_test
       hosts:
-        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+        <% SpecConfig.instance.addresses.each do |address| %>
+          - <%= address %>
+        <% end %>
       options:
         read:
           mode: :primary_preferred
           max_staleness: 100
+        server_selection_timeout: 3.14

data/spec/config/mongoid_with_schema_map_uuid.yml

@@ -0,0 +1,27 @@
+test:
+  clients:
+    default:
+      database: mongoid_test
+      hosts:
+        <% SpecConfig.instance.addresses.each do |address| %>
+          - <%= address %>
+        <% end %>
+      options:
+        auto_encryption_options:
+          key_vault_namespace: 'admin.datakeys'
+          kms_providers:
+            local:
+              key: "z7iYiYKLuYymEWtk4kfny1ESBwwFdA58qMqff96A8ghiOcIK75lJGPUIocku8LOFjQuEgeIP4xlln3s7r93FV9J5sAE7zg8U"
+          schema_map:
+            blog_development.comments:
+              properties:
+                message:
+                  encrypt:
+                    keyId:
+                      - !ruby/object:BSON::Binary
+                        data: !binary |-
+                          R/AgNcxASFiiJWKXqWGo5w==
+                        type: :uuid
+                    bsonType: "string"
+                    algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+              bsonType: "object"

data/spec/integration/app_spec.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+BASE = File.join(File.dirname(__FILE__), '../..')
+TMP_BASE = File.join(BASE, 'tmp')
+
+def check_call(cmd, **opts)
+  puts "Executing #{cmd.join(' ')}"
+  Mrss::ChildProcessHelper.check_call(cmd, **opts)
+end
+
+describe 'Mongoid application tests' do
+  before(:all) do
+    unless SpecConfig.instance.app_tests?
+      skip 'Set APP_TESTS=1 in environment to run application tests'
+    end
+
+    require 'fileutils'
+    require 'mrss/child_process_helper'
+    require 'open-uri'
+
+    FileUtils.mkdir_p(TMP_BASE)
+  end
+
+  context 'demo application' do
+    context 'sinatra' do
+      it 'runs' do
+        clone_application(
+          'https://github.com/mongoid/mongoid-demo',
+          subdir: 'sinatra-minimal',
+        ) do
+
+          # JRuby needs a long timeout
+          start_app(%w(bundle exec ruby app.rb), 4567, 40) do |port|
+            uri = URI.parse('http://localhost:4567/posts')
+            resp = JSON.parse(uri.open.read)
+
+            resp.should == []
+
+          end
+        end
+      end
+    end
+
+    context 'rails-api' do
+      it 'runs' do
+        clone_application(
+          'https://github.com/mongoid/mongoid-demo',
+          subdir: 'rails-api',
+        ) do
+
+          # JRuby needs a long timeout
+          start_app(%w(bundle exec rails s), 3000, 50) do |port|
+            uri = URI.parse('http://localhost:3000/posts')
+            resp = JSON.parse(uri.open.read)
+
+            resp.should == []
+          end
+        end
+      end
+    end
+  end
+
+  def start_app(cmd, port, timeout)
+    process = ChildProcess.build(*cmd)
+    process.environment.update(clean_env)
+    process.io.inherit!
+    process.start
+
+    begin
+      wait_for_port(port, timeout, process)
+      sleep 1
+
+      rv = yield port
+    ensure
+      # The process may have already died (due to an error exit) -
+      # in this case killing it will raise an exception.
+      Process.kill('TERM', process.pid) rescue nil
+      status = process.wait
+    end
+
+    # Exit should be either success or SIGTERM
+    [0, 15, 128 + 15].should include(status)
+
+    rv
+  end
+
+  context 'new application - rails' do
+    it 'creates' do
+      install_rails
+
+      Dir.chdir(TMP_BASE) do
+        FileUtils.rm_rf('mongoid-test')
+        check_call(%w(rails new mongoid-test --skip-spring --skip-active-record), env: clean_env)
+
+        Dir.chdir('mongoid-test') do
+          adjust_app_gemfile
+          check_call(%w(bundle install), env: clean_env)
+
+          check_call(%w(rails g model post), env: clean_env)
+          check_call(%w(rails g model comment post:belongs_to), env: clean_env)
+
+          # https://jira.mongodb.org/browse/MONGOID-4885
+          comment_text = File.read('app/models/comment.rb')
+          comment_text.should =~ /belongs_to :post/
+          comment_text.should_not =~ /embedded_in :post/
+        end
+      end
+    end
+
+    it 'generates Mongoid config' do
+      install_rails
+
+      Dir.chdir(TMP_BASE) do
+        FileUtils.rm_rf('mongoid-test-config')
+        check_call(%w(rails new mongoid-test-config --skip-spring --skip-active-record), env: clean_env)
+
+        Dir.chdir('mongoid-test-config') do
+          adjust_app_gemfile
+          check_call(%w(bundle install), env: clean_env)
+
+          mongoid_config_file = File.join(TMP_BASE,'mongoid-test-config/config/mongoid.yml')
+
+          File.exist?(mongoid_config_file).should be false
+          check_call(%w(rails g mongoid:config), env: clean_env)
+          File.exist?(mongoid_config_file).should be true
+
+          config_text = File.read(mongoid_config_file)
+          config_text.should =~ /mongoid_test_config_development/
+          config_text.should =~ /mongoid_test_config_test/
+        end
+      end
+    end
+  end
+
+  def install_rails
+    check_call(%w(gem uni rails -a))
+    if (rails_version = SpecConfig.instance.rails_version) == 'master'
+    else
+      check_call(%w(gem list))
+      check_call(%w(gem install rails --no-document -v) + ["~> #{rails_version}.0"])
+    end
+  end
+
+  context 'local test applications' do
+    let(:client) { Mongoid.default_client }
+
+    describe 'create_indexes rake task' do
+
+      APP_PATH = File.join(File.dirname(__FILE__), '../../test-apps/rails-api')
+
+      %w(development production).each do |rails_env|
+        context "in #{rails_env}" do
+
+          %w(classic zeitwerk).each do |autoloader|
+            context "with #{autoloader} autoloader" do
+
+              let(:env) do
+                clean_env.merge(RAILS_ENV: rails_env, AUTOLOADER: autoloader)
+              end
+
+              before do
+                Dir.chdir(APP_PATH) do
+                  remove_bundler_req
+
+                  if BSON::Environment.jruby?
+                    # Remove existing Gemfile.lock - see
+                    # https://github.com/rubygems/rubygems/issues/3231
+                    require 'fileutils'
+                    FileUtils.rm_f('Gemfile.lock')
+                  end
+
+                  check_call(%w(bundle install), env: env)
+                  write_mongoid_yml
+                end
+
+                client['posts'].drop
+                client['posts'].create
+              end
+
+              it 'creates an index' do
+                index = client['posts'].indexes.detect do |index|
+                  index['key'] == {'subject' => 1}
+                end
+                index.should be nil
+
+                check_call(%w(bundle exec rake db:mongoid:create_indexes -t),
+                  cwd: APP_PATH, env: env)
+
+                index = client['posts'].indexes.detect do |index|
+                  index['key'] == {'subject' => 1}
+                end
+                index.should be_a(Hash)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def clone_application(repo_url, subdir: nil)
+    Dir.chdir(TMP_BASE) do
+      FileUtils.rm_rf(File.basename(repo_url))
+      check_call(%w(git clone) + [repo_url])
+      Dir.chdir(File.join(*[File.basename(repo_url), subdir].compact)) do
+        adjust_app_gemfile
+        adjust_rails_defaults
+        check_call(%w(bundle install), env: clean_env)
+        puts `git diff`
+
+        write_mongoid_yml
+
+        yield
+      end
+    end
+  end
+
+  def parse_mongodb_uri(uri)
+    pre, query = uri.split('?', 2)
+    if pre =~ %r,\A(mongodb(?:.*?))://([^/]+)(?:/(.*))?\z,
+      protocol = $1
+      hosts = $2
+      database = $3
+      if database == ''
+        database = nil
+      end
+    else
+      raise ArgumentError, "Invalid MongoDB URI: #{uri}"
+    end
+    if query == ''
+      query = nil
+    end
+    {
+      protocol: protocol,
+      hosts: hosts,
+      database: database,
+      query: query,
+    }
+  end
+
+  def build_mongodb_uri(parts)
+    "#{parts.fetch(:protocol)}://#{parts.fetch(:hosts)}/#{parts[:database]}?#{parts[:query]}"
+  end
+
+  def write_mongoid_yml
+    # HACK: the driver does not provide a MongoDB URI parser and assembler,
+    # and the Ruby standard library URI module doesn't handle multiple hosts.
+    parts = parse_mongodb_uri(SpecConfig.instance.uri_str)
+    parts[:database] = 'mongoid_test'
+    uri = build_mongodb_uri(parts)
+    p uri
+    env_config = {'clients' => {'default' => {
+      # TODO massive hack, will fail if uri specifies a database name or
+      # any uri options
+      'uri' => uri,
+    }}}
+    config = {'development' => env_config, 'production' => env_config}
+    File.open('config/mongoid.yml', 'w') do |f|
+      f << YAML.dump(config)
+    end
+  end
+
+  def adjust_app_gemfile(rails_version: SpecConfig.instance.rails_version)
+    remove_bundler_req
+
+    gemfile_lines = IO.readlines('Gemfile')
+    gemfile_lines.delete_if do |line|
+      line =~ /mongoid/
+    end
+    gemfile_lines << "gem 'mongoid', path: '#{File.expand_path(BASE)}'\n"
+    if rails_version
+      gemfile_lines.delete_if do |line|
+        line =~ /rails/
+      end
+      if rails_version == 'master'
+        gemfile_lines << "gem 'rails', git: 'https://github.com/rails/rails'\n"
+      else
+        gemfile_lines << "gem 'rails', '~> #{rails_version}.0'\n"
+      end
+    end
+    File.open('Gemfile', 'w') do |f|
+      f << gemfile_lines.join
+    end
+  end
+
+  def adjust_rails_defaults(rails_version: SpecConfig.instance.rails_version)
+    if File.exist?('config/application.rb')
+      lines = IO.readlines('config/application.rb')
+      lines.each do |line|
+        line.gsub!(/config.load_defaults \d\.\d/, "config.load_defaults #{rails_version}")
+      end
+      File.open('config/application.rb', 'w') do |f|
+        f << lines.join
+      end
+    end
+  end
+
+  def remove_bundler_req
+    return unless File.file?('Gemfile.lock')
+    # TODO: Remove this method completely when we get rid of .lock files in
+    # mongoid-demo apps.
+    lock_lines = IO.readlines('Gemfile.lock')
+    # Get rid of the bundled with line so that whatever bundler is installed
+    # on the system is usable with the application.
+    if i = lock_lines.index("BUNDLED WITH\n")
+      lock_lines.slice!(i, 2)
+      File.open('Gemfile.lock', 'w') do |f|
+        f << lock_lines.join
+      end
+    end
+  end
+
+  def remove_spring
+    # Spring produces this error in Evergreen:
+    # /data/mci/280eb2ecf4fd69208e2106cd3af526f1/src/rubies/ruby-2.7.0/lib/ruby/gems/2.7.0/gems/spring-2.1.0/lib/spring/client/run.rb:26:
+    # in `initialize': too long unix socket path (126bytes given but 108bytes max) (ArgumentError)
+    # Is it trying to create unix sockets in current directory?
+    # https://stackoverflow.com/questions/30302021/rails-runner-without-spring
+    check_call(%w(bin/spring binstub --remove --all), env: clean_env)
+  end
+
+  def clean_env
+    @clean_env ||= Hash[ENV.keys.grep(/BUNDLE|RUBYOPT/).map { |k| [k, nil ] }]
+  end
+
+  def wait_for_port(port, timeout, process)
+    deadline = Mongoid::Utils.monotonic_time + timeout
+    loop do
+      begin
+        Socket.tcp('localhost', port, nil, nil, connect_timeout: 0.5) do |socket|
+          return
+        end
+      rescue IOError, SystemCallError
+        unless process.alive?
+          raise "Process #{process} died while waiting for port #{port}"
+        end
+        if Mongoid::Utils.monotonic_time > deadline
+          raise
+        end
+      end
+    end
+  end
+end