Run in-app rails commands via fork+load where possible

While this avoids shell argument parsing, we still pass through
everything in our stack.

1 files changed, 38 insertions, 44 deletions

diff --git a/railties/test/application/rake/dbs_test.rb b/railties/test/application/rake/dbs_test.rb
index db88eb0fd3..391676aa31 100644
--- a/railties/test/application/rake/dbs_test.rb
+++ b/railties/test/application/rake/dbs_test.rb
@@ -28,11 +28,11 @@ module ApplicationTests
 
       def db_create_and_drop(expected_database)
         Dir.chdir(app_path) do
-          output = `bin/rails db:create`
+          output = rails("db:create")
           assert_match(/Created database/, output)
           assert File.exist?(expected_database)
           assert_equal expected_database, ActiveRecord::Base.connection_config[:database]
-          output = `bin/rails db:drop`
+          output = rails("db:drop")
           assert_match(/Dropped database/, output)
           assert !File.exist?(expected_database)
         end
@@ -52,17 +52,16 @@ module ApplicationTests
       def with_database_existing
         Dir.chdir(app_path) do
           set_database_url
-          `bin/rails db:create`
+          rails "db:create"
           yield
-          `bin/rails db:drop`
+          rails "db:drop"
         end
       end
 
       test "db:create failure because database exists" do
         with_database_existing do
-          output = `bin/rails db:create 2>&1`
+          output = rails("db:create")
           assert_match(/already exists/, output)
-          assert_equal 0, $?.exitstatus
         end
       end
 
@@ -77,7 +76,7 @@ module ApplicationTests
 
       test "db:create failure because bad permissions" do
         with_bad_permissions do
-          output = `bin/rails db:create 2>&1`
+          output = rails("db:create", allow_failure: true)
           assert_match(/Couldn't create database/, output)
           assert_equal 1, $?.exitstatus
         end
@@ -85,16 +84,15 @@ module ApplicationTests
 
       test "db:drop failure because database does not exist" do
         Dir.chdir(app_path) do
-          output = `bin/rails db:drop:_unsafe --trace 2>&1`
+          output = rails("db:drop:_unsafe", "--trace")
           assert_match(/does not exist/, output)
-          assert_equal 0, $?.exitstatus
         end
       end
 
       test "db:drop failure because bad permissions" do
         with_database_existing do
           with_bad_permissions do
-            output = `bin/rails db:drop 2>&1`
+            output = rails("db:drop", allow_failure: true)
             assert_match(/Couldn't drop/, output)
             assert_equal 1, $?.exitstatus
           end
@@ -103,9 +101,9 @@ module ApplicationTests
 
       def db_migrate_and_status(expected_database)
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate`
-          output = `bin/rails db:migrate:status`
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate"
+          output = rails("db:migrate:status")
           assert_match(%r{database:\s+\S*#{Regexp.escape(expected_database)}}, output)
           assert_match(/up\s+\d{14}\s+Create books/, output)
         end
@@ -124,8 +122,8 @@ module ApplicationTests
 
       def db_schema_dump
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:schema:dump`
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate", "db:schema:dump"
           schema_dump = File.read("db/schema.rb")
           assert_match(/create_table \"books\"/, schema_dump)
         end
@@ -142,8 +140,8 @@ module ApplicationTests
 
       def db_fixtures_load(expected_database)
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:fixtures:load`
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate", "db:fixtures:load"
           assert_match expected_database, ActiveRecord::Base.connection_config[:database]
           require "#{app_path}/app/models/book"
           assert_equal 2, Book.count
@@ -164,8 +162,8 @@ module ApplicationTests
       test "db:fixtures:load with namespaced fixture" do
         require "#{app_path}/config/environment"
         Dir.chdir(app_path) do
-          `bin/rails generate model admin::book title:string;
-           bin/rails db:migrate db:fixtures:load`
+          rails "generate", "model", "admin::book", "title:string"
+          rails "db:migrate", "db:fixtures:load"
           require "#{app_path}/app/models/admin/book"
           assert_equal 2, Admin::Book.count
         end
@@ -173,11 +171,11 @@ module ApplicationTests
 
       def db_structure_dump_and_load(expected_database)
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:structure:dump`
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate", "db:structure:dump"
           structure_dump = File.read("db/structure.sql")
           assert_match(/CREATE TABLE (?:IF NOT EXISTS )?\"books\"/, structure_dump)
-          `bin/rails environment db:drop db:structure:load`
+          rails "environment", "db:drop", "db:structure:load"
           assert_match expected_database, ActiveRecord::Base.connection_config[:database]
           require "#{app_path}/app/models/book"
           #if structure is not loaded correctly, exception would be raised
@@ -197,20 +195,18 @@ module ApplicationTests
       end
 
       test "db:structure:dump does not dump schema information when no migrations are used" do
-        Dir.chdir(app_path) do
-          # create table without migrations
-          `bin/rails runner 'ActiveRecord::Base.connection.create_table(:posts) {|t| t.string :title }'`
+        # create table without migrations
+        rails "runner", "ActiveRecord::Base.connection.create_table(:posts) {|t| t.string :title }"
 
-          stderr_output = capture(:stderr) { `bin/rails db:structure:dump` }
-          assert_empty stderr_output
-          structure_dump = File.read("db/structure.sql")
-          assert_match(/CREATE TABLE (?:IF NOT EXISTS )?\"posts\"/, structure_dump)
-        end
+        stderr_output = capture(:stderr) { rails("db:structure:dump", stderr: true, allow_failure: true) }
+        assert_empty stderr_output
+        structure_dump = File.read("#{app_path}/db/structure.sql")
+        assert_match(/CREATE TABLE (?:IF NOT EXISTS )?\"posts\"/, structure_dump)
       end
 
       test "db:schema:load and db:structure:load do not purge the existing database" do
         Dir.chdir(app_path) do
-          `bin/rails runner 'ActiveRecord::Base.connection.create_table(:posts) {|t| t.string :title }'`
+          rails "runner", "ActiveRecord::Base.connection.create_table(:posts) {|t| t.string :title }"
 
           app_file "db/schema.rb", <<-RUBY
             ActiveRecord::Schema.define(version: 20140423102712) do
@@ -218,17 +214,17 @@ module ApplicationTests
             end
           RUBY
 
-          list_tables = lambda { `bin/rails runner 'p ActiveRecord::Base.connection.tables'`.strip }
+          list_tables = lambda { rails("runner", "p ActiveRecord::Base.connection.tables").strip }
 
           assert_equal '["posts"]', list_tables[]
-          `bin/rails db:schema:load`
+          rails "db:schema:load"
           assert_equal '["posts", "comments", "schema_migrations", "ar_internal_metadata"]', list_tables[]
 
           app_file "db/structure.sql", <<-SQL
             CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255));
           SQL
 
-          `bin/rails db:structure:load`
+          rails "db:structure:load"
           assert_equal '["posts", "comments", "schema_migrations", "ar_internal_metadata", "users"]', list_tables[]
         end
       end
@@ -251,27 +247,25 @@ module ApplicationTests
             end
           RUBY
 
-          `bin/rails db:schema:load`
+          rails "db:schema:load"
 
-          tables = `bin/rails runner 'p ActiveRecord::Base.connection.tables'`.strip
+          tables = rails("runner", "p ActiveRecord::Base.connection.tables").strip
           assert_match(/"geese"/, tables)
 
-          columns = `bin/rails runner 'p ActiveRecord::Base.connection.columns("geese").map(&:name)'`.strip
+          columns = rails("runner", "p ActiveRecord::Base.connection.columns('geese').map(&:name)").strip
           assert_equal columns, '["gooseid", "name"]'
         end
       end
 
       test "db:schema:load fails if schema.rb doesn't exist yet" do
-        Dir.chdir(app_path) do
-          stderr_output = capture(:stderr) { `bin/rails db:schema:load` }
-          assert_match(/Run `rails db:migrate` to create it/, stderr_output)
-        end
+        stderr_output = capture(:stderr) { rails("db:schema:load", stderr: true, allow_failure: true) }
+        assert_match(/Run `rails db:migrate` to create it/, stderr_output)
       end
 
       def db_test_load_structure
         Dir.chdir(app_path) do
-          `bin/rails generate model book title:string;
-           bin/rails db:migrate db:structure:dump db:test:load_structure`
+          rails "generate", "model", "book", "title:string"
+          rails "db:migrate", "db:structure:dump", "db:test:load_structure"
           ActiveRecord::Base.configurations = Rails.application.config.database_configuration
           ActiveRecord::Base.establish_connection :test
           require "#{app_path}/app/models/book"
@@ -307,7 +301,7 @@ module ApplicationTests
           RUBY
 
           Dir.chdir(app_path) do
-            database_path = `bin/rails db:setup`
+            database_path = rails("db:setup")
             assert_equal "development.sqlite3", File.basename(database_path.strip)
           end
         ensure