debian-mirror-gitlab/spec/tasks/gitlab/db_rake_spec.rb

206 lines
8.5 KiB
Ruby
Raw Normal View History

2019-12-21 20:55:43 +05:30
# frozen_string_literal: true
require 'spec_helper'
require 'rake'
2020-07-28 23:09:34 +05:30
RSpec.describe 'gitlab:db namespace rake task' do
before :all do
Rake.application.rake_require 'active_record/railties/databases'
Rake.application.rake_require 'tasks/seed_fu'
Rake.application.rake_require 'tasks/gitlab/db'
# empty task as env is already loaded
Rake::Task.define_task :environment
end
before do
# Stub out db tasks
allow(Rake::Task['db:migrate']).to receive(:invoke).and_return(true)
2020-04-22 19:07:51 +05:30
allow(Rake::Task['db:structure:load']).to receive(:invoke).and_return(true)
allow(Rake::Task['db:seed_fu']).to receive(:invoke).and_return(true)
end
describe 'configure' do
2016-09-13 17:45:13 +05:30
it 'invokes db:migrate when schema has already been loaded' do
2018-11-08 19:23:39 +05:30
allow(ActiveRecord::Base.connection).to receive(:tables).and_return(%w[table1 table2])
expect(Rake::Task['db:migrate']).to receive(:invoke)
2020-04-22 19:07:51 +05:30
expect(Rake::Task['db:structure:load']).not_to receive(:invoke)
expect(Rake::Task['db:seed_fu']).not_to receive(:invoke)
expect { run_rake_task('gitlab:db:configure') }.not_to raise_error
end
2016-09-13 17:45:13 +05:30
it 'invokes db:shema:load and db:seed_fu when schema is not loaded' do
allow(ActiveRecord::Base.connection).to receive(:tables).and_return([])
2020-04-22 19:07:51 +05:30
expect(Rake::Task['db:structure:load']).to receive(:invoke)
expect(Rake::Task['db:seed_fu']).to receive(:invoke)
expect(Rake::Task['db:migrate']).not_to receive(:invoke)
expect { run_rake_task('gitlab:db:configure') }.not_to raise_error
end
2018-11-08 19:23:39 +05:30
it 'invokes db:shema:load and db:seed_fu when there is only a single table present' do
allow(ActiveRecord::Base.connection).to receive(:tables).and_return(['default'])
2020-04-22 19:07:51 +05:30
expect(Rake::Task['db:structure:load']).to receive(:invoke)
2018-11-08 19:23:39 +05:30
expect(Rake::Task['db:seed_fu']).to receive(:invoke)
expect(Rake::Task['db:migrate']).not_to receive(:invoke)
expect { run_rake_task('gitlab:db:configure') }.not_to raise_error
end
2016-09-13 17:45:13 +05:30
it 'does not invoke any other rake tasks during an error' do
allow(ActiveRecord::Base).to receive(:connection).and_raise(RuntimeError, 'error')
expect(Rake::Task['db:migrate']).not_to receive(:invoke)
2020-04-22 19:07:51 +05:30
expect(Rake::Task['db:structure:load']).not_to receive(:invoke)
expect(Rake::Task['db:seed_fu']).not_to receive(:invoke)
expect { run_rake_task('gitlab:db:configure') }.to raise_error(RuntimeError, 'error')
# unstub connection so that the database cleaner still works
allow(ActiveRecord::Base).to receive(:connection).and_call_original
end
2016-09-13 17:45:13 +05:30
it 'does not invoke seed after a failed schema_load' do
allow(ActiveRecord::Base.connection).to receive(:tables).and_return([])
2020-04-22 19:07:51 +05:30
allow(Rake::Task['db:structure:load']).to receive(:invoke).and_raise(RuntimeError, 'error')
expect(Rake::Task['db:structure:load']).to receive(:invoke)
expect(Rake::Task['db:seed_fu']).not_to receive(:invoke)
expect(Rake::Task['db:migrate']).not_to receive(:invoke)
expect { run_rake_task('gitlab:db:configure') }.to raise_error(RuntimeError, 'error')
end
2018-12-05 23:21:45 +05:30
context 'SKIP_POST_DEPLOYMENT_MIGRATIONS environment variable set' do
let(:rails_paths) { { 'db' => ['db'], 'db/migrate' => ['db/migrate'] } }
before do
allow(ENV).to receive(:[]).and_call_original
allow(ENV).to receive(:[]).with('SKIP_POST_DEPLOYMENT_MIGRATIONS').and_return true
# Our environment has already been loaded, so we need to pretend like post_migrations were not
allow(Rails.application.config).to receive(:paths).and_return(rails_paths)
allow(ActiveRecord::Migrator).to receive(:migrations_paths).and_return(rails_paths['db/migrate'].dup)
end
it 'adds post deployment migrations before schema load if the schema is not already loaded' do
allow(ActiveRecord::Base.connection).to receive(:tables).and_return([])
expect(Gitlab::Database).to receive(:add_post_migrate_path_to_rails).and_call_original
2020-04-22 19:07:51 +05:30
expect(Rake::Task['db:structure:load']).to receive(:invoke)
2018-12-05 23:21:45 +05:30
expect(Rake::Task['db:seed_fu']).to receive(:invoke)
expect(Rake::Task['db:migrate']).not_to receive(:invoke)
expect { run_rake_task('gitlab:db:configure') }.not_to raise_error
expect(rails_paths['db/migrate'].include?(File.join(Rails.root, 'db', 'post_migrate'))).to be(true)
end
it 'ignores post deployment migrations when schema has already been loaded' do
allow(ActiveRecord::Base.connection).to receive(:tables).and_return(%w[table1 table2])
expect(Rake::Task['db:migrate']).to receive(:invoke)
expect(Gitlab::Database).not_to receive(:add_post_migrate_path_to_rails)
2020-04-22 19:07:51 +05:30
expect(Rake::Task['db:structure:load']).not_to receive(:invoke)
2018-12-05 23:21:45 +05:30
expect(Rake::Task['db:seed_fu']).not_to receive(:invoke)
expect { run_rake_task('gitlab:db:configure') }.not_to raise_error
expect(rails_paths['db/migrate'].include?(File.join(Rails.root, 'db', 'post_migrate'))).to be(false)
end
end
end
2020-04-22 19:07:51 +05:30
describe 'clean_structure_sql' do
let_it_be(:clean_rake_task) { 'gitlab:db:clean_structure_sql' }
let_it_be(:test_task_name) { 'gitlab:db:_test_multiple_structure_cleans' }
let_it_be(:structure_file) { 'db/structure.sql' }
let_it_be(:input) { 'this is structure data' }
let(:output) { StringIO.new }
before do
allow(File).to receive(:read).with(structure_file).and_return(input)
allow(File).to receive(:open).with(structure_file, any_args).and_yield(output)
end
after do
Rake::Task[test_task_name].clear if Rake::Task.task_defined?(test_task_name)
end
it 'can be executed multiple times within another rake task' do
2020-06-23 00:09:42 +05:30
expect_multiple_executions_of_task(test_task_name, clean_rake_task) do
2020-04-22 19:07:51 +05:30
expect_next_instance_of(Gitlab::Database::SchemaCleaner) do |cleaner|
expect(cleaner).to receive(:clean).with(output)
end
2020-06-23 00:09:42 +05:30
end
end
end
2020-04-22 19:07:51 +05:30
2020-06-23 00:09:42 +05:30
describe 'load_custom_structure' do
let_it_be(:db_config) { Rails.application.config_for(:database) }
let_it_be(:custom_load_task) { 'gitlab:db:load_custom_structure' }
let_it_be(:custom_filepath) { Pathname.new('db/directory') }
it 'uses the psql command to load the custom structure file' do
expect(Gitlab::Database::CustomStructure).to receive(:custom_dump_filepath).and_return(custom_filepath)
expect(Kernel).to receive(:system)
.with('psql', any_args, custom_filepath.to_path, db_config['database']).and_return(true)
run_rake_task(custom_load_task)
end
it 'raises an error when the call to the psql command fails' do
expect(Gitlab::Database::CustomStructure).to receive(:custom_dump_filepath).and_return(custom_filepath)
expect(Kernel).to receive(:system)
.with('psql', any_args, custom_filepath.to_path, db_config['database']).and_return(nil)
expect { run_rake_task(custom_load_task) }.to raise_error(/failed to execute:\s*psql/)
end
end
describe 'dump_custom_structure' do
let_it_be(:test_task_name) { 'gitlab:db:_test_multiple_task_executions' }
let_it_be(:custom_dump_task) { 'gitlab:db:dump_custom_structure' }
after do
Rake::Task[test_task_name].clear if Rake::Task.task_defined?(test_task_name)
end
it 'can be executed multiple times within another rake task' do
expect_multiple_executions_of_task(test_task_name, custom_dump_task) do
expect_next_instance_of(Gitlab::Database::CustomStructure) do |custom_structure|
expect(custom_structure).to receive(:dump)
2020-04-22 19:07:51 +05:30
end
end
end
end
2020-11-24 15:15:51 +05:30
describe 'reindex' do
context 'when no index_name is given' do
it 'raises an error' do
expect do
run_rake_task('gitlab:db:reindex', '')
end.to raise_error(ArgumentError, /must give the index name/)
end
end
it 'calls the index rebuilder with the proper arguments' do
reindex = double('rebuilder')
expect(Gitlab::Database::ConcurrentReindex).to receive(:new)
.with('some_index_name', logger: instance_of(Logger))
.and_return(reindex)
expect(reindex).to receive(:execute)
run_rake_task('gitlab:db:reindex', '[some_index_name]')
end
end
def run_rake_task(task_name, arguments = '')
Rake::Task[task_name].reenable
2020-11-24 15:15:51 +05:30
Rake.application.invoke_task("#{task_name}#{arguments}")
end
2020-06-23 00:09:42 +05:30
def expect_multiple_executions_of_task(test_task_name, task_to_invoke, count: 2)
Rake::Task.define_task(test_task_name => :environment) do
count.times do
yield
Rake::Task[task_to_invoke].invoke
end
end
run_rake_task(test_task_name)
end
end