mongoid 7.1.11 → 7.2.0.rc1

data/spec/integration/app_spec.rb

@@ -13,131 +13,109 @@ describe 'Mongoid application tests' do
     end
 
     require 'fileutils'
-    require 'mrss/child_process_helper'
+    require 'support/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
+  context 'demo application - sinatra' do
+    it 'runs' do
+      clone_application(
+        'https://github.com/mongoid/mongoid-demo',
+        subdir: 'sinatra-minimal',
+      ) do
 
+        process = ChildProcess.build(*%w(bundle exec ruby app.rb))
+        process.environment.update(clean_env)
+        process.io.inherit!
+        process.start
+
+        begin
           # 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)
+          wait_for_port(4567, 20)
+          sleep 1
+
+          uri = URI.parse('http://localhost:4567/posts')
+          resp = JSON.parse(uri.open.read)
+        ensure
+          Process.kill('TERM', process.pid)
+          status = process.wait
+        end
 
-            resp.should == []
+        resp.should == []
 
-          end
-        end
+        status.should == 0
       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)
+  context 'demo application - rails-api' do
+    ['~> 6.0.0'].each do |rails_version|
+      context "with rails #{rails_version}" do
+        it 'runs' do
+          clone_application(
+            'https://github.com/mongoid/mongoid-demo',
+            subdir: 'rails-api',
+            rails_version: rails_version,
+          ) do
+
+            process = ChildProcess.build(*%w(bundle exec rails s))
+            process.environment.update(clean_env)
+            process.io.inherit!
+            process.start
+
+            begin
+              # JRuby needs a long timeout
+              wait_for_port(3000, 30)
+              sleep 1
+
+              uri = URI.parse('http://localhost:3000/posts')
+              resp = JSON.parse(uri.open.read)
+            ensure
+              Process.kill('TERM', process.pid)
+              status = process.wait
+            end
 
             resp.should == []
+
+            # 143 = 128 + 15
+            [0, 15, 143].should include(status)
           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')
-        Mrss::ChildProcessHelper.check_call(%w(rails new mongoid-test --skip-spring --skip-active-record), env: clean_env)
-
-        Dir.chdir('mongoid-test') do
-          adjust_app_gemfile
-          Mrss::ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
-
-          Mrss::ChildProcessHelper.check_call(%w(rails g model post), env: clean_env)
-          Mrss::ChildProcessHelper.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')
-        Mrss::ChildProcessHelper.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
-          Mrss::ChildProcessHelper.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
-          Mrss::ChildProcessHelper.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/
+    ['~> 5.1.0', '~> 5.2.0', '~> 6.0.0'].each do |rails_version|
+      context "with rails #{rails_version}" do
+        it 'creates' do
+          ChildProcessHelper.check_call(%w(gem uni rails -a))
+          ChildProcessHelper.check_call(%w(gem install rails --no-document -v) + [rails_version])
+
+          Dir.chdir(TMP_BASE) do
+            FileUtils.rm_rf('mongoid-test')
+            ChildProcessHelper.check_call(%w(rails new mongoid-test --skip-spring --skip-active-record), env: clean_env)
+
+            Dir.chdir('mongoid-test') do
+              adjust_app_gemfile
+              ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+
+              ChildProcessHelper.check_call(%w(rails g model post), env: clean_env)
+              ChildProcessHelper.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
       end
     end
   end
 
-  def install_rails
-    Mrss::ChildProcessHelper.check_call(%w(gem uni rails -a))
-    if (rails_version = SpecConfig.instance.rails_version) == 'master'
-    else
-      Mrss::ChildProcessHelper.check_call(%w(gem install rails --no-document -v) + [rails_version])
-    end
-  end
-
   context 'local test applications' do
     let(:client) { Mongoid.default_client }
 
@@ -158,7 +136,7 @@ describe 'Mongoid application tests' do
               before do
                 Dir.chdir(APP_PATH) do
                   remove_bundler_req
-                  Mrss::ChildProcessHelper.check_call(%w(bundle install), env: env)
+                  ChildProcessHelper.check_call(%w(bundle install), env: env)
                   write_mongoid_yml
                 end
 
@@ -172,7 +150,7 @@ describe 'Mongoid application tests' do
                 end
                 index.should be nil
 
-                Mrss::ChildProcessHelper.check_call(%w(bundle exec rake db:mongoid:create_indexes),
+                ChildProcessHelper.check_call(%w(rake db:mongoid:create_indexes),
                   cwd: APP_PATH, env: env)
 
                 index = client['posts'].indexes.detect do |index|
@@ -187,14 +165,13 @@ describe 'Mongoid application tests' do
     end
   end
 
-  def clone_application(repo_url, subdir: nil)
+  def clone_application(repo_url, subdir: nil, rails_version: nil)
     Dir.chdir(TMP_BASE) do
       FileUtils.rm_rf(File.basename(repo_url))
-      Mrss::ChildProcessHelper.check_call(%w(git clone) + [repo_url])
+      ChildProcessHelper.check_call(%w(git clone) + [repo_url])
       Dir.chdir(File.join(*[File.basename(repo_url), subdir].compact)) do
-        adjust_app_gemfile
-        adjust_rails_defaults
-        Mrss::ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+        adjust_app_gemfile(rails_version: rails_version)
+        ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
         puts `git diff`
 
         write_mongoid_yml
@@ -204,44 +181,11 @@ describe 'Mongoid application tests' do
     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,
+      'uri' => "#{SpecConfig.instance.uri_str}/mongoid_test",
     }}}
     config = {'development' => env_config, 'production' => env_config}
     File.open('config/mongoid.yml', 'w') do |f|
@@ -249,7 +193,7 @@ describe 'Mongoid application tests' do
     end
   end
 
-  def adjust_app_gemfile(rails_version: SpecConfig.instance.rails_version)
+  def adjust_app_gemfile(rails_version: nil)
     remove_bundler_req
 
     gemfile_lines = IO.readlines('Gemfile')
@@ -261,45 +205,14 @@ describe 'Mongoid application tests' do
       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
+      gemfile_lines << "gem 'rails', '#{rails_version}'\n"
     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
-
-    if rails_version == '5.1'
-      secrets = {
-        'development' => {
-          'secret_key_base' => 'abracadabra',
-          'my_secret_token' => 'very_secret',
-        },
-      }
-      File.open('config/secrets.yml', 'w') do |f|
-        f << YAML.dump(secrets)
-      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.
@@ -317,14 +230,14 @@ describe 'Mongoid application tests' do
     # 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
-    Mrss::ChildProcessHelper.check_call(%w(bin/spring binstub --remove --all), env: clean_env)
+    ChildProcessHelper.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)
+  def wait_for_port(port, timeout)
     deadline = Time.now + timeout
     loop do
       begin
@@ -332,9 +245,6 @@ describe 'Mongoid application tests' do
           return
         end
       rescue IOError, SystemCallError
-        unless process.alive?
-          raise "Process #{process} died while waiting for port #{port}"
-        end
         if Time.now > deadline
           raise
         end

data/spec/integration/associations/embedded_spec.rb

@@ -172,4 +172,98 @@ describe 'embedded associations' do
       end
     end
   end
+
+  describe 'updated_at on parent' do
+    context 'when child is added' do
+      context 'embeds_one' do
+        let(:parent) { EomParent.create! }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.child = EomChild.new
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+
+      context 'embeds_many' do
+        let(:parent) { EmmCongress.create! }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.legislators << EmmLegislator.new
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+    end
+
+    context 'when child is updated' do
+      context 'embeds_one' do
+        let(:parent) { EomParent.create!(child: EomChild.new) }
+
+        it 'updates' do
+          first_updated_at = parent.updated_at
+
+          parent.child.a = 42
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+
+      context 'embeds_many' do
+        let(:parent) { EmmCongress.create!(legislators: [EmmLegislator.new]) }
+
+        it 'updates' do
+          first_updated_at = parent.updated_at
+
+          parent.legislators.first.a = 42
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+    end
+
+    context 'when child is removed' do
+      context 'embeds_one' do
+        let(:parent) { EomParent.create!(child: EomChild.new) }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.child = nil
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+
+      context 'embeds_many' do
+        let(:parent) { EmmCongress.create!(legislators: [EmmLegislator.new]) }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.legislators.clear
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+    end
+  end
 end

data/spec/integration/associations/has_many_spec.rb

@@ -2,74 +2,67 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'mongoid/association/referenced/has_many_models'
 
 describe 'has_many associations' do
   context 'destroying parent in transaction with dependent child' do
     require_transaction_support
 
-    let(:artist) { Artist.create! }
-    let(:album) { Album.create!(artist: artist) }
+    let(:company) { HmmCompany.create! }
+    let(:address) { HmmAddress.create!(company: company) }
 
     before do
-      Artist.delete_all
-      Album.delete_all
-
-      album
+      Company.delete_all
+      Address.delete_all
     end
 
-    it 'works' do
-      Artist.count.should == 1
-      Album.count.should == 1
-
-      artist.with_session do |session|
-        session.with_transaction do
-          artist.destroy
+    context 'dependent: :destroy' do
+      before do
+        HmmCompany.class_eval do
+          has_one :address, class_name: 'HmmAddress', dependent: :destroy
         end
       end
 
-      Artist.count.should == 0
-      Album.count.should == 0
-    end
-  end
+      it 'destroys' do
+        address
 
-  context 're-associating the same object' do
-    context 'with dependent: destroy' do
-      let(:wiki_page) do
-        WikiPage.create!
-      end
+        HmmCompany.count.should == 1
+        HmmAddress.count.should == 1
 
-      let!(:comment) do
-        Comment.create!(wiki_page: wiki_page, title: 'hi') do
-          wiki_page.reload
+        company.with_session do |session|
+          session.with_transaction do
+            company.destroy!
+          end
         end
-      end
 
-      it 'does not destroy the dependent object' do
-        wiki_page.comments.should == [comment]
-        wiki_page.comments = [comment]
-        wiki_page.save!
-        wiki_page.reload
-        wiki_page.comments.should == [comment]
+        HmmCompany.count.should == 0
+        HmmAddress.count.should == 0
       end
     end
 
-    context 'without dependent: destroy' do
-      let(:series) do
-        Series.create!
-      end
-
-      let!(:book) do
-        Book.create!(series: series).tap do
-          series.reload
+    context 'dependent: :restrict_with_error' do
+      before do
+        HmmCompany.class_eval do
+          has_one :address, class_name: 'HmmAddress', dependent: :restrict_with_error
         end
       end
 
-      it 'does not destroy the dependent object' do
-        series.books.should == [book]
-        series.books = [book]
-        series.save!
-        series.reload
-        series.books.should == [book]
+      it 'destroys' do
+        address
+
+        HmmCompany.count.should == 1
+        HmmAddress.count.should == 1
+
+        lambda do
+          company.with_session do |session|
+            session.with_transaction do
+              company.destroy!
+            end
+          end
+        end.should raise_error(Mongoid::Errors::DocumentNotDestroyed)
+
+        HmmCompany.count.should == 1
+        HmmAddress.count.should == 1
       end
     end
   end