Merge branch '52442-initial-mysql-support-removal' into 'master'

Remove dead mysql code

Closes #63191

See merge request gitlab-org/gitlab-ce!29608

11 files changed, 225 insertions, 739 deletions

diff --git a/spec/features/projects/new_project_spec.rb b/spec/features/projects/new_project_spec.rb
index fe7b4b759a8..7602935b47e 100644
--- a/spec/features/projects/new_project_spec.rb
+++ b/spec/features/projects/new_project_spec.rb
@@ -62,13 +62,7 @@ describe 'New project' do
         find('#import-project-tab').click
       end
 
-      context 'when using postgres', :postgresql do
-        it { expect(page).to have_link('Manifest file') }
-      end
-
-      context 'when using mysql', :mysql do
-        it { expect(page).not_to have_link('Manifest file') }
-      end
+      it { expect(page).to have_link('Manifest file') }
     end
 
     context 'Visibility level selector', :js do
diff --git a/spec/lib/forever_spec.rb b/spec/lib/forever_spec.rb
index b9ffe895bf0..800fa5a6ad6 100644
--- a/spec/lib/forever_spec.rb
+++ b/spec/lib/forever_spec.rb
@@ -4,19 +4,9 @@ describe Forever do
   describe '.date' do
     subject { described_class.date }
 
-    context 'when using PostgreSQL' do
-      it 'returns Postgresql future date' do
-        allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
-
-        expect(subject).to eq(described_class::POSTGRESQL_DATE)
-      end
-    end
-
-    context 'when using MySQL' do
-      it 'returns MySQL future date' do
-        allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
-
-        expect(subject).to eq(described_class::MYSQL_DATE)
+    it 'returns Postgresql future date' do
+      Timecop.travel(Date.new(2999, 12, 31)) do
+        is_expected.to be > Date.today
       end
     end
   end
diff --git a/spec/lib/gitlab/cycle_analytics/usage_data_spec.rb b/spec/lib/gitlab/cycle_analytics/usage_data_spec.rb
index ad61bdeace7..258ab049c0b 100644
--- a/spec/lib/gitlab/cycle_analytics/usage_data_spec.rb
+++ b/spec/lib/gitlab/cycle_analytics/usage_data_spec.rb
@@ -28,27 +28,7 @@ describe Gitlab::CycleAnalytics::UsageData do
       end
     end
 
-    shared_examples 'a valid usage data result' do
-      it 'returns the aggregated usage data of every selected project' do
-        result = subject.to_json
-
-        expect(result).to have_key(:avg_cycle_analytics)
-
-        CycleAnalytics::LevelBase::STAGES.each do |stage|
-          expect(result[:avg_cycle_analytics]).to have_key(stage)
-
-          stage_values    = result[:avg_cycle_analytics][stage]
-          expected_values = expect_values_per_stage[stage]
-
-          expected_values.each_pair do |op, value|
-            expect(stage_values).to have_key(op)
-            expect(stage_values[op]).to eq(value)
-          end
-        end
-      end
-    end
-
-    context 'when using postgresql', :postgresql do
+    context 'a valid usage data result' do
       let(:expect_values_per_stage) do
         {
           issue: {
@@ -89,51 +69,23 @@ describe Gitlab::CycleAnalytics::UsageData do
         }
       end
 
-      it_behaves_like 'a valid usage data result'
-    end
+      it 'returns the aggregated usage data of every selected project' do
+        result = subject.to_json
 
-    context 'when using mysql', :mysql do
-      let(:expect_values_per_stage) do
-        {
-          issue: {
-            average: nil,
-            sd: 0,
-            missing: 2
-          },
-          plan: {
-            average: nil,
-            sd: 0,
-            missing: 2
-          },
-          code: {
-            average: nil,
-            sd: 0,
-            missing: 2
-          },
-          test: {
-            average: nil,
-            sd: 0,
-            missing: 2
-          },
-          review: {
-            average: nil,
-            sd: 0,
-            missing: 2
-          },
-          staging: {
-            average: nil,
-            sd: 0,
-            missing: 2
-          },
-          production: {
-            average: nil,
-            sd: 0,
-            missing: 2
-          }
-        }
-      end
+        expect(result).to have_key(:avg_cycle_analytics)
+
+        CycleAnalytics::LevelBase::STAGES.each do |stage|
+          expect(result[:avg_cycle_analytics]).to have_key(stage)
 
-      it_behaves_like 'a valid usage data result'
+          stage_values    = result[:avg_cycle_analytics][stage]
+          expected_values = expect_values_per_stage[stage]
+
+          expected_values.each_pair do |op, value|
+            expect(stage_values).to have_key(op)
+            expect(stage_values[op]).to eq(value)
+          end
+        end
+      end
     end
   end
 end
diff --git a/spec/lib/gitlab/database/median_spec.rb b/spec/lib/gitlab/database/median_spec.rb
deleted file mode 100644
index 1b5e30089ce..00000000000
--- a/spec/lib/gitlab/database/median_spec.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Gitlab::Database::Median do
-  let(:dummy_class) do
-    Class.new do
-      include Gitlab::Database::Median
-    end
-  end
-
-  subject(:median) { dummy_class.new }
-
-  describe '#median_datetimes' do
-    it 'raises NotSupportedError', :mysql do
-      expect { median.median_datetimes(nil, nil, nil, :project_id) }.to raise_error(dummy_class::NotSupportedError, "partition_column is not supported for MySQL")
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/migration_helpers_spec.rb b/spec/lib/gitlab/database/migration_helpers_spec.rb
index dd0033bbc14..b73828b9554 100644
--- a/spec/lib/gitlab/database/migration_helpers_spec.rb
+++ b/spec/lib/gitlab/database/migration_helpers_spec.rb
@@ -30,85 +30,66 @@ describe Gitlab::Database::MigrationHelpers do
 
     before do
       allow(model).to receive(:transaction_open?).and_return(in_transaction)
+      allow(model).to receive(:disable_statement_timeout)
     end
 
-    context 'using PostgreSQL' do
-      before do
-        allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
-        allow(model).to receive(:disable_statement_timeout)
-      end
-
-      it 'adds "created_at" and "updated_at" fields with the "datetime_with_timezone" data type' do
-        Gitlab::Database::MigrationHelpers::DEFAULT_TIMESTAMP_COLUMNS.each do |column_name|
-          expect(model).to receive(:add_column).with(:foo, column_name, :datetime_with_timezone, { null: false })
-        end
-
-        model.add_timestamps_with_timezone(:foo)
-      end
-
-      it 'can disable the NOT NULL constraint' do
-        Gitlab::Database::MigrationHelpers::DEFAULT_TIMESTAMP_COLUMNS.each do |column_name|
-          expect(model).to receive(:add_column).with(:foo, column_name, :datetime_with_timezone, { null: true })
-        end
-
-        model.add_timestamps_with_timezone(:foo, null: true)
+    it 'adds "created_at" and "updated_at" fields with the "datetime_with_timezone" data type' do
+      Gitlab::Database::MigrationHelpers::DEFAULT_TIMESTAMP_COLUMNS.each do |column_name|
+        expect(model).to receive(:add_column).with(:foo, column_name, :datetime_with_timezone, { null: false })
       end
 
-      it 'can add just one column' do
-        expect(model).to receive(:add_column).with(:foo, :created_at, :datetime_with_timezone, anything)
-        expect(model).not_to receive(:add_column).with(:foo, :updated_at, :datetime_with_timezone, anything)
+      model.add_timestamps_with_timezone(:foo)
+    end
 
-        model.add_timestamps_with_timezone(:foo, columns: [:created_at])
+    it 'can disable the NOT NULL constraint' do
+      Gitlab::Database::MigrationHelpers::DEFAULT_TIMESTAMP_COLUMNS.each do |column_name|
+        expect(model).to receive(:add_column).with(:foo, column_name, :datetime_with_timezone, { null: true })
       end
 
-      it 'can add choice of acceptable columns' do
-        expect(model).to receive(:add_column).with(:foo, :created_at, :datetime_with_timezone, anything)
-        expect(model).to receive(:add_column).with(:foo, :deleted_at, :datetime_with_timezone, anything)
-        expect(model).not_to receive(:add_column).with(:foo, :updated_at, :datetime_with_timezone, anything)
-
-        model.add_timestamps_with_timezone(:foo, columns: [:created_at, :deleted_at])
-      end
+      model.add_timestamps_with_timezone(:foo, null: true)
+    end
 
-      it 'cannot add unacceptable column names' do
-        expect do
-          model.add_timestamps_with_timezone(:foo, columns: [:bar])
-        end.to raise_error %r/Illegal timestamp column name/
-      end
+    it 'can add just one column' do
+      expect(model).to receive(:add_column).with(:foo, :created_at, :datetime_with_timezone, anything)
+      expect(model).not_to receive(:add_column).with(:foo, :updated_at, :datetime_with_timezone, anything)
 
-      context 'in a transaction' do
-        let(:in_transaction) { true }
+      model.add_timestamps_with_timezone(:foo, columns: [:created_at])
+    end
 
-        before do
-          allow(model).to receive(:add_column).with(any_args).and_call_original
-          allow(model).to receive(:add_column)
-            .with(:foo, anything, :datetime_with_timezone, anything)
-            .and_return(nil)
-        end
+    it 'can add choice of acceptable columns' do
+      expect(model).to receive(:add_column).with(:foo, :created_at, :datetime_with_timezone, anything)
+      expect(model).to receive(:add_column).with(:foo, :deleted_at, :datetime_with_timezone, anything)
+      expect(model).not_to receive(:add_column).with(:foo, :updated_at, :datetime_with_timezone, anything)
 
-        it 'cannot add a default value' do
-          expect do
-            model.add_timestamps_with_timezone(:foo, default: :i_cause_an_error)
-          end.to raise_error %r/add_timestamps_with_timezone/
-        end
+      model.add_timestamps_with_timezone(:foo, columns: [:created_at, :deleted_at])
+    end
 
-        it 'can add columns without defaults' do
-          expect do
-            model.add_timestamps_with_timezone(:foo)
-          end.not_to raise_error
-        end
-      end
+    it 'cannot add unacceptable column names' do
+      expect do
+        model.add_timestamps_with_timezone(:foo, columns: [:bar])
+      end.to raise_error %r/Illegal timestamp column name/
     end
 
-    context 'using MySQL' do
+    context 'in a transaction' do
+      let(:in_transaction) { true }
+
       before do
-        allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
+        allow(model).to receive(:add_column).with(any_args).and_call_original
+        allow(model).to receive(:add_column)
+          .with(:foo, anything, :datetime_with_timezone, anything)
+          .and_return(nil)
       end
 
-      it 'adds "created_at" and "updated_at" fields with "datetime_with_timezone" data type' do
-        expect(model).to receive(:add_column).with(:foo, :created_at, :datetime_with_timezone, { null: false })
-        expect(model).to receive(:add_column).with(:foo, :updated_at, :datetime_with_timezone, { null: false })
+      it 'cannot add a default value' do
+        expect do
+          model.add_timestamps_with_timezone(:foo, default: :i_cause_an_error)
+        end.to raise_error %r/add_timestamps_with_timezone/
+      end
 
-        model.add_timestamps_with_timezone(:foo)
+      it 'can add columns without defaults' do
+        expect do
+          model.add_timestamps_with_timezone(:foo)
+        end.not_to raise_error
       end
     end
   end
@@ -117,56 +98,29 @@ describe Gitlab::Database::MigrationHelpers do
     context 'outside a transaction' do
       before do
         allow(model).to receive(:transaction_open?).and_return(false)
+        allow(model).to receive(:disable_statement_timeout).and_call_original
       end
 
-      context 'using PostgreSQL', :postgresql do
-        before do
-          allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
-          allow(model).to receive(:disable_statement_timeout).and_call_original
-        end
-
-        it 'creates the index concurrently' do
-          expect(model).to receive(:add_index)
-            .with(:users, :foo, algorithm: :concurrently)
+      it 'creates the index concurrently' do
+        expect(model).to receive(:add_index)
+          .with(:users, :foo, algorithm: :concurrently)
 
-          model.add_concurrent_index(:users, :foo)
-        end
-
-        it 'creates unique index concurrently' do
-          expect(model).to receive(:add_index)
-            .with(:users, :foo, { algorithm: :concurrently, unique: true })
-
-          model.add_concurrent_index(:users, :foo, unique: true)
-        end
-
-        it 'does nothing if the index exists already' do
-          expect(model).to receive(:index_exists?)
-            .with(:users, :foo, { algorithm: :concurrently, unique: true }).and_return(true)
-          expect(model).not_to receive(:add_index)
-
-          model.add_concurrent_index(:users, :foo, unique: true)
-        end
+        model.add_concurrent_index(:users, :foo)
       end
 
-      context 'using MySQL' do
-        before do
-          allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
-        end
+      it 'creates unique index concurrently' do
+        expect(model).to receive(:add_index)
+          .with(:users, :foo, { algorithm: :concurrently, unique: true })
 
-        it 'creates a regular index' do
-          expect(model).to receive(:add_index)
-            .with(:users, :foo, {})
-
-          model.add_concurrent_index(:users, :foo)
-        end
+        model.add_concurrent_index(:users, :foo, unique: true)
+      end
 
-        it 'does nothing if the index exists already' do
-          expect(model).to receive(:index_exists?)
-            .with(:users, :foo, { unique: true }).and_return(true)
-          expect(model).not_to receive(:add_index)
+      it 'does nothing if the index exists already' do
+        expect(model).to receive(:index_exists?)
+          .with(:users, :foo, { algorithm: :concurrently, unique: true }).and_return(true)
+        expect(model).not_to receive(:add_index)
 
-          model.add_concurrent_index(:users, :foo, unique: true)
-        end
+        model.add_concurrent_index(:users, :foo, unique: true)
       end
     end
 
@@ -186,28 +140,23 @@ describe Gitlab::Database::MigrationHelpers do
         allow(model).to receive(:transaction_open?).and_return(false)
         allow(model).to receive(:index_exists?).and_return(true)
         allow(model).to receive(:disable_statement_timeout).and_call_original
+        allow(model).to receive(:supports_drop_index_concurrently?).and_return(true)
       end
 
-      context 'using PostgreSQL' do
-        before do
-          allow(model).to receive(:supports_drop_index_concurrently?).and_return(true)
-        end
-
-        describe 'by column name' do
-          it 'removes the index concurrently' do
-            expect(model).to receive(:remove_index)
-              .with(:users, { algorithm: :concurrently, column: :foo })
+      describe 'by column name' do
+        it 'removes the index concurrently' do
+          expect(model).to receive(:remove_index)
+            .with(:users, { algorithm: :concurrently, column: :foo })
 
-            model.remove_concurrent_index(:users, :foo)
-          end
+          model.remove_concurrent_index(:users, :foo)
+        end
 
-          it 'does nothing if the index does not exist' do
-            expect(model).to receive(:index_exists?)
-              .with(:users, :foo, { algorithm: :concurrently, unique: true }).and_return(false)
-            expect(model).not_to receive(:remove_index)
+        it 'does nothing if the index does not exist' do
+          expect(model).to receive(:index_exists?)
+            .with(:users, :foo, { algorithm: :concurrently, unique: true }).and_return(false)
+          expect(model).not_to receive(:remove_index)
 
-            model.remove_concurrent_index(:users, :foo, unique: true)
-          end
+          model.remove_concurrent_index(:users, :foo, unique: true)
         end
 
         describe 'by index name' do
@@ -230,17 +179,6 @@ describe Gitlab::Database::MigrationHelpers do
           end
         end
       end
-
-      context 'using MySQL' do
-        it 'removes an index' do
-          expect(Gitlab::Database).to receive(:postgresql?).and_return(false).twice
-
-          expect(model).to receive(:remove_index)
-            .with(:users, { column: :foo })
-
-          model.remove_concurrent_index(:users, :foo)
-        end
-      end
     end
 
     context 'inside a transaction' do
@@ -273,88 +211,44 @@ describe Gitlab::Database::MigrationHelpers do
         allow(model).to receive(:transaction_open?).and_return(false)
       end
 
-      context 'using MySQL' do
-        before do
-          allow(Gitlab::Database).to receive(:mysql?).and_return(true)
-        end
+      it 'creates a concurrent foreign key and validates it' do
+        expect(model).to receive(:disable_statement_timeout).and_call_original
+        expect(model).to receive(:execute).with(/statement_timeout/)
+        expect(model).to receive(:execute).ordered.with(/NOT VALID/)
+        expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT/)
+        expect(model).to receive(:execute).with(/RESET ALL/)
 
-        it 'creates a regular foreign key' do
-          expect(model).to receive(:add_foreign_key)
-            .with(:projects, :users, column: :user_id, on_delete: :cascade)
-
-          model.add_concurrent_foreign_key(:projects, :users, column: :user_id)
-        end
-
-        it 'allows the use of a custom key name' do
-          expect(model).to receive(:add_foreign_key).with(
-            :projects,
-            :users,
-            column: :user_id,
-            on_delete: :cascade,
-            name: :foo
-          )
-
-          model.add_concurrent_foreign_key(
-            :projects,
-            :users,
-            column: :user_id,
-            name: :foo
-          )
-        end
-
-        it 'does not create a foreign key if it exists already' do
-          expect(model).to receive(:foreign_key_exists?).with(:projects, :users, column: :user_id).and_return(true)
-          expect(model).not_to receive(:add_foreign_key)
-
-          model.add_concurrent_foreign_key(:projects, :users, column: :user_id)
-        end
+        model.add_concurrent_foreign_key(:projects, :users, column: :user_id)
       end
 
-      context 'using PostgreSQL' do
-        before do
-          allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
-          allow(Gitlab::Database).to receive(:mysql?).and_return(false)
-        end
-
-        it 'creates a concurrent foreign key and validates it' do
-          expect(model).to receive(:disable_statement_timeout).and_call_original
-          expect(model).to receive(:execute).with(/statement_timeout/)
-          expect(model).to receive(:execute).ordered.with(/NOT VALID/)
-          expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT/)
-          expect(model).to receive(:execute).with(/RESET ALL/)
+      it 'appends a valid ON DELETE statement' do
+        expect(model).to receive(:disable_statement_timeout).and_call_original
+        expect(model).to receive(:execute).with(/statement_timeout/)
+        expect(model).to receive(:execute).with(/ON DELETE SET NULL/)
+        expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT/)
+        expect(model).to receive(:execute).with(/RESET ALL/)
 
-          model.add_concurrent_foreign_key(:projects, :users, column: :user_id)
-        end
-
-        it 'appends a valid ON DELETE statement' do
-          expect(model).to receive(:disable_statement_timeout).and_call_original
-          expect(model).to receive(:execute).with(/statement_timeout/)
-          expect(model).to receive(:execute).with(/ON DELETE SET NULL/)
-          expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT/)
-          expect(model).to receive(:execute).with(/RESET ALL/)
-
-          model.add_concurrent_foreign_key(:projects, :users,
-                                           column: :user_id,
-                                           on_delete: :nullify)
-        end
+        model.add_concurrent_foreign_key(:projects, :users,
+                                         column: :user_id,
+                                         on_delete: :nullify)
+      end
 
-        it 'does not create a foreign key if it exists already' do
-          expect(model).to receive(:foreign_key_exists?).with(:projects, :users, column: :user_id).and_return(true)
-          expect(model).not_to receive(:execute).with(/ADD CONSTRAINT/)
-          expect(model).to receive(:execute).with(/VALIDATE CONSTRAINT/)
+      it 'does not create a foreign key if it exists already' do
+        expect(model).to receive(:foreign_key_exists?).with(:projects, :users, column: :user_id).and_return(true)
+        expect(model).not_to receive(:execute).with(/ADD CONSTRAINT/)
+        expect(model).to receive(:execute).with(/VALIDATE CONSTRAINT/)
 
-          model.add_concurrent_foreign_key(:projects, :users, column: :user_id)
-        end
+        model.add_concurrent_foreign_key(:projects, :users, column: :user_id)
+      end
 
-        it 'allows the use of a custom key name' do
-          expect(model).to receive(:disable_statement_timeout).and_call_original
-          expect(model).to receive(:execute).with(/statement_timeout/)
-          expect(model).to receive(:execute).ordered.with(/NOT VALID/)
-          expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT.+foo/)
-          expect(model).to receive(:execute).with(/RESET ALL/)
+      it 'allows the use of a custom key name' do
+        expect(model).to receive(:disable_statement_timeout).and_call_original
+        expect(model).to receive(:execute).with(/statement_timeout/)
+        expect(model).to receive(:execute).ordered.with(/NOT VALID/)
+        expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT.+foo/)
+        expect(model).to receive(:execute).with(/RESET ALL/)
 
-          model.add_concurrent_foreign_key(:projects, :users, column: :user_id, name: :foo)
-        end
+        model.add_concurrent_foreign_key(:projects, :users, column: :user_id, name: :foo)
       end
     end
   end
@@ -393,48 +287,43 @@ describe Gitlab::Database::MigrationHelpers do
   end
 
   describe '#disable_statement_timeout' do
-    context 'using PostgreSQL' do
-      it 'disables statement timeouts to current transaction only' do
-        expect(Gitlab::Database).to receive(:postgresql?).and_return(true)
+    it 'disables statement timeouts to current transaction only' do
+      expect(model).to receive(:execute).with('SET LOCAL statement_timeout TO 0')
 
-        expect(model).to receive(:execute).with('SET LOCAL statement_timeout TO 0')
+      model.disable_statement_timeout
+    end
 
-        model.disable_statement_timeout
+    # this specs runs without an enclosing transaction (:delete truncation method for db_cleaner)
+    context 'with real environment', :delete do
+      before do
+        model.execute("SET statement_timeout TO '20000'")
       end
 
-      # this specs runs without an enclosing transaction (:delete truncation method for db_cleaner)
-      context 'with real environment', :postgresql, :delete do
-        before do
-          model.execute("SET statement_timeout TO '20000'")
-        end
-
-        after do
-          model.execute('RESET ALL')
-        end
-
-        it 'defines statement to 0 only for current transaction' do
-          expect(model.execute('SHOW statement_timeout').first['statement_timeout']).to eq('20s')
+      after do
+        model.execute('RESET ALL')
+      end
 
-          model.connection.transaction do
-            model.disable_statement_timeout
-            expect(model.execute('SHOW statement_timeout').first['statement_timeout']).to eq('0')
-          end
+      it 'defines statement to 0 only for current transaction' do
+        expect(model.execute('SHOW statement_timeout').first['statement_timeout']).to eq('20s')
 
-          expect(model.execute('SHOW statement_timeout').first['statement_timeout']).to eq('20s')
+        model.connection.transaction do
+          model.disable_statement_timeout
+          expect(model.execute('SHOW statement_timeout').first['statement_timeout']).to eq('0')
         end
+
+        expect(model.execute('SHOW statement_timeout').first['statement_timeout']).to eq('20s')
       end
 
       context 'when passing a blocks' do
         it 'disables statement timeouts on session level and executes the block' do
-          expect(Gitlab::Database).to receive(:postgresql?).and_return(true)
           expect(model).to receive(:execute).with('SET statement_timeout TO 0')
-          expect(model).to receive(:execute).with('RESET ALL')
+          expect(model).to receive(:execute).with('RESET ALL').at_least(:once)
 
           expect { |block| model.disable_statement_timeout(&block) }.to yield_control
         end
 
         # this specs runs without an enclosing transaction (:delete truncation method for db_cleaner)
-        context 'with real environment', :postgresql, :delete do
+        context 'with real environment', :delete do
           before do
             model.execute("SET statement_timeout TO '20000'")
           end
@@ -457,69 +346,17 @@ describe Gitlab::Database::MigrationHelpers do
         end
       end
     end
-
-    context 'using MySQL' do
-      it 'does nothing' do
-        expect(Gitlab::Database).to receive(:postgresql?).and_return(false)
-
-        expect(model).not_to receive(:execute)
-
-        model.disable_statement_timeout
-      end
-
-      context 'when passing a blocks' do
-        it 'executes the block of code' do
-          expect(Gitlab::Database).to receive(:postgresql?).and_return(false)
-
-          expect(model).not_to receive(:execute)
-
-          expect { |block| model.disable_statement_timeout(&block) }.to yield_control
-        end
-      end
-    end
   end
 
   describe '#true_value' do
-    context 'using PostgreSQL' do
-      before do
-        expect(Gitlab::Database).to receive(:postgresql?).and_return(true)
-      end
-
-      it 'returns the appropriate value' do
-        expect(model.true_value).to eq("'t'")
-      end
-    end
-
-    context 'using MySQL' do
-      before do
-        expect(Gitlab::Database).to receive(:postgresql?).and_return(false)
-      end
-
-      it 'returns the appropriate value' do
-        expect(model.true_value).to eq(1)
-      end
+    it 'returns the appropriate value' do
+      expect(model.true_value).to eq("'t'")
     end
   end
 
   describe '#false_value' do
-    context 'using PostgreSQL' do
-      before do
-        expect(Gitlab::Database).to receive(:postgresql?).and_return(true)
-      end
-
-      it 'returns the appropriate value' do
-        expect(model.false_value).to eq("'f'")
-      end
-    end
-
-    context 'using MySQL' do
-      before do
-        expect(Gitlab::Database).to receive(:postgresql?).and_return(false)
-      end
-
-      it 'returns the appropriate value' do
-        expect(model.false_value).to eq(0)
-      end
+    it 'returns the appropriate value' do
+      expect(model.false_value).to eq("'f'")
     end
   end
 
@@ -711,77 +548,37 @@ describe Gitlab::Database::MigrationHelpers do
       before do
         allow(model).to receive(:transaction_open?).and_return(false)
         allow(model).to receive(:column_for).and_return(old_column)
-
-        # Since MySQL and PostgreSQL use different quoting styles we'll just
-        # stub the methods used for this to make testing easier.
-        allow(model).to receive(:quote_column_name) { |name| name.to_s }
-        allow(model).to receive(:quote_table_name) { |name| name.to_s }
       end
 
-      context 'using MySQL' do
-        it 'renames a column concurrently' do
-          allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
+      it 'renames a column concurrently' do
+        expect(model).to receive(:check_trigger_permissions!).with(:users)
 
-          expect(model).to receive(:check_trigger_permissions!).with(:users)
+        expect(model).to receive(:install_rename_triggers_for_postgresql)
+          .with(trigger_name, '"users"', '"old"', '"new"')
 
-          expect(model).to receive(:install_rename_triggers_for_mysql)
-            .with(trigger_name, 'users', 'old', 'new')
+        expect(model).to receive(:add_column)
+          .with(:users, :new, :integer,
+               limit: old_column.limit,
+               precision: old_column.precision,
+               scale: old_column.scale)
 
-          expect(model).to receive(:add_column)
-            .with(:users, :new, :integer,
-                 limit: old_column.limit,
-                 precision: old_column.precision,
-                 scale: old_column.scale)
+        expect(model).to receive(:change_column_default)
+          .with(:users, :new, old_column.default)
 
-          expect(model).to receive(:change_column_default)
-            .with(:users, :new, old_column.default)
-
-          expect(model).to receive(:update_column_in_batches)
+        expect(model).to receive(:update_column_in_batches)
 
-          expect(model).to receive(:change_column_null).with(:users, :new, false)
+        expect(model).to receive(:change_column_null).with(:users, :new, false)
 
-          expect(model).to receive(:copy_indexes).with(:users, :old, :new)
-          expect(model).to receive(:copy_foreign_keys).with(:users, :old, :new)
+        expect(model).to receive(:copy_indexes).with(:users, :old, :new)
+        expect(model).to receive(:copy_foreign_keys).with(:users, :old, :new)
 
-          model.rename_column_concurrently(:users, :old, :new)
-        end
-      end
-
-      context 'using PostgreSQL' do
-        it 'renames a column concurrently' do
-          allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
-
-          expect(model).to receive(:check_trigger_permissions!).with(:users)
-
-          expect(model).to receive(:install_rename_triggers_for_postgresql)
-            .with(trigger_name, 'users', 'old', 'new')
-
-          expect(model).to receive(:add_column)
-            .with(:users, :new, :integer,
-                 limit: old_column.limit,
-                 precision: old_column.precision,
-                 scale: old_column.scale)
-
-          expect(model).to receive(:change_column_default)
-            .with(:users, :new, old_column.default)
-
-          expect(model).to receive(:update_column_in_batches)
-
-          expect(model).to receive(:change_column_null).with(:users, :new, false)
-
-          expect(model).to receive(:copy_indexes).with(:users, :old, :new)
-          expect(model).to receive(:copy_foreign_keys).with(:users, :old, :new)
-
-          model.rename_column_concurrently(:users, :old, :new)
-        end
+        model.rename_column_concurrently(:users, :old, :new)
       end
     end
   end
 
   describe '#cleanup_concurrent_column_rename' do
-    it 'cleans up the renaming procedure for PostgreSQL' do
-      allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
-
+    it 'cleans up the renaming procedure' do
       expect(model).to receive(:check_trigger_permissions!).with(:users)
 
       expect(model).to receive(:remove_rename_triggers_for_postgresql)
@@ -791,19 +588,6 @@ describe Gitlab::Database::MigrationHelpers do
 
       model.cleanup_concurrent_column_rename(:users, :old, :new)
     end
-
-    it 'cleans up the renaming procedure for MySQL' do
-      allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
-
-      expect(model).to receive(:check_trigger_permissions!).with(:users)
-
-      expect(model).to receive(:remove_rename_triggers_for_mysql)
-        .with(/trigger_.{12}/)
-
-      expect(model).to receive(:remove_column).with(:users, :old)
-
-      model.cleanup_concurrent_column_rename(:users, :old, :new)
-    end
   end
 
   describe '#change_column_type_concurrently' do
@@ -839,18 +623,6 @@ describe Gitlab::Database::MigrationHelpers do
     end
   end
 
-  describe '#install_rename_triggers_for_mysql' do
-    it 'installs the triggers for MySQL' do
-      expect(model).to receive(:execute)
-        .with(/CREATE TRIGGER foo_insert.+ON users/m)
-
-      expect(model).to receive(:execute)
-        .with(/CREATE TRIGGER foo_update.+ON users/m)
-
-      model.install_rename_triggers_for_mysql('foo', :users, :old, :new)
-    end
-  end
-
   describe '#remove_rename_triggers_for_postgresql' do
     it 'removes the function and trigger' do
       expect(model).to receive(:execute).with('DROP TRIGGER IF EXISTS foo ON bar')
@@ -860,15 +632,6 @@ describe Gitlab::Database::MigrationHelpers do
     end
   end
 
-  describe '#remove_rename_triggers_for_mysql' do
-    it 'removes the triggers' do
-      expect(model).to receive(:execute).with('DROP TRIGGER IF EXISTS foo_insert')
-      expect(model).to receive(:execute).with('DROP TRIGGER IF EXISTS foo_update')
-
-      model.remove_rename_triggers_for_mysql('foo')
-    end
-  end
-
   describe '#rename_trigger_name' do
     it 'returns a String' do
       expect(model.rename_trigger_name(:users, :foo, :bar))
@@ -1088,26 +851,9 @@ describe Gitlab::Database::MigrationHelpers do
   end
 
   describe '#replace_sql' do
-    context 'using postgres' do
-      before do
-        allow(Gitlab::Database).to receive(:mysql?).and_return(false)
-      end
-
-      it 'builds the sql with correct functions' do
-        expect(model.replace_sql(Arel::Table.new(:users)[:first_name], "Alice", "Eve").to_s)
-          .to include('regexp_replace')
-      end
-    end
-
-    context 'using mysql' do
-      before do
-        allow(Gitlab::Database).to receive(:mysql?).and_return(true)
-      end
-
-      it 'builds the sql with the correct functions' do
-        expect(model.replace_sql(Arel::Table.new(:users)[:first_name], "Alice", "Eve").to_s)
-          .to include('locate', 'insert')
-      end
+    it 'builds the sql with correct functions' do
+      expect(model.replace_sql(Arel::Table.new(:users)[:first_name], "Alice", "Eve").to_s)
+        .to include('regexp_replace')
     end
 
     describe 'results' do
@@ -1464,7 +1210,7 @@ describe Gitlab::Database::MigrationHelpers do
         .to be_falsy
     end
 
-    context 'when an index with a function exists', :postgresql do
+    context 'when an index with a function exists' do
       before do
         ActiveRecord::Base.connection.execute(
           'CREATE INDEX test_index ON projects (LOWER(path));'
diff --git a/spec/lib/gitlab/database_spec.rb b/spec/lib/gitlab/database_spec.rb
index 5f57cd6b825..9e8712266e8 100644
--- a/spec/lib/gitlab/database_spec.rb
+++ b/spec/lib/gitlab/database_spec.rb
@@ -24,21 +24,13 @@ describe Gitlab::Database do
       expect(described_class.human_adapter_name).to eq('PostgreSQL')
     end
 
-    it 'returns MySQL when using MySQL' do
+    it 'returns Unknown when using anything else' do
       allow(described_class).to receive(:postgresql?).and_return(false)
 
-      expect(described_class.human_adapter_name).to eq('MySQL')
+      expect(described_class.human_adapter_name).to eq('Unknown')
     end
   end
 
-  # These are just simple smoke tests to check if the methods work (regardless
-  # of what they may return).
-  describe '.mysql?' do
-    subject { described_class.mysql? }
-
-    it { is_expected.to satisfy { |val| val == true || val == false } }
-  end
-
   describe '.postgresql?' do
     subject { described_class.postgresql? }
 
@@ -52,15 +44,6 @@ describe Gitlab::Database do
       described_class.instance_variable_set(:@version, nil)
     end
 
-    context "on mysql" do
-      it "extracts the version number" do
-        allow(described_class).to receive(:database_version)
-          .and_return("5.7.12-standard")
-
-        expect(described_class.version).to eq '5.7.12-standard'
-      end
-    end
-
     context "on postgresql" do
       it "extracts the version number" do
         allow(described_class).to receive(:database_version)
@@ -80,7 +63,7 @@ describe Gitlab::Database do
   end
 
   describe '.postgresql_9_or_less?' do
-    it 'returns false when using MySQL' do
+    it 'returns false when not using postgresql' do
       allow(described_class).to receive(:postgresql?).and_return(false)
 
       expect(described_class.postgresql_9_or_less?).to eq(false)
@@ -134,7 +117,7 @@ describe Gitlab::Database do
   end
 
   describe '.join_lateral_supported?' do
-    it 'returns false when using MySQL' do
+    it 'returns false when not using postgresql' do
       allow(described_class).to receive(:postgresql?).and_return(false)
 
       expect(described_class.join_lateral_supported?).to eq(false)
@@ -156,7 +139,7 @@ describe Gitlab::Database do
   end
 
   describe '.replication_slots_supported?' do
-    it 'returns false when using MySQL' do
+    it 'returns false when not using postgresql' do
       allow(described_class).to receive(:postgresql?).and_return(false)
 
       expect(described_class.replication_slots_supported?).to eq(false)
@@ -248,43 +231,13 @@ describe Gitlab::Database do
   end
 
   describe '.nulls_last_order' do
-    context 'when using PostgreSQL' do
-      before do
-        expect(described_class).to receive(:postgresql?).and_return(true)
-      end
-
-      it { expect(described_class.nulls_last_order('column', 'ASC')).to eq 'column ASC NULLS LAST'}
-      it { expect(described_class.nulls_last_order('column', 'DESC')).to eq 'column DESC NULLS LAST'}
-    end
-
-    context 'when using MySQL' do
-      before do
-        expect(described_class).to receive(:postgresql?).and_return(false)
-      end
-
-      it { expect(described_class.nulls_last_order('column', 'ASC')).to eq 'column IS NULL, column ASC'}
-      it { expect(described_class.nulls_last_order('column', 'DESC')).to eq 'column DESC'}
-    end
+    it { expect(described_class.nulls_last_order('column', 'ASC')).to eq 'column ASC NULLS LAST'}
+    it { expect(described_class.nulls_last_order('column', 'DESC')).to eq 'column DESC NULLS LAST'}
   end
 
   describe '.nulls_first_order' do
-    context 'when using PostgreSQL' do
-      before do
-        expect(described_class).to receive(:postgresql?).and_return(true)
-      end
-
-      it { expect(described_class.nulls_first_order('column', 'ASC')).to eq 'column ASC NULLS FIRST'}
-      it { expect(described_class.nulls_first_order('column', 'DESC')).to eq 'column DESC NULLS FIRST'}
-    end
-
-    context 'when using MySQL' do
-      before do
-        expect(described_class).to receive(:postgresql?).and_return(false)
-      end
-
-      it { expect(described_class.nulls_first_order('column', 'ASC')).to eq 'column ASC'}
-      it { expect(described_class.nulls_first_order('column', 'DESC')).to eq 'column IS NULL, column DESC'}
-    end
+    it { expect(described_class.nulls_first_order('column', 'ASC')).to eq 'column ASC NULLS FIRST'}
+    it { expect(described_class.nulls_first_order('column', 'DESC')).to eq 'column DESC NULLS FIRST'}
   end
 
   describe '.with_connection_pool' do
@@ -394,10 +347,6 @@ describe Gitlab::Database do
     end
 
     context 'when using PostgreSQL' do
-      before do
-        allow(described_class).to receive(:mysql?).and_return(false)
-      end
-
       it 'allows the returning of the IDs of the inserted rows' do
         result = double(:result, values: [['10']])
 
@@ -463,31 +412,15 @@ describe Gitlab::Database do
   end
 
   describe '#true_value' do
-    it 'returns correct value for PostgreSQL' do
-      expect(described_class).to receive(:postgresql?).and_return(true)
-
+    it 'returns correct value' do
       expect(described_class.true_value).to eq "'t'"
     end
-
-    it 'returns correct value for MySQL' do
-      expect(described_class).to receive(:postgresql?).and_return(false)
-
-      expect(described_class.true_value).to eq 1
-    end
   end
 
   describe '#false_value' do
-    it 'returns correct value for PostgreSQL' do
-      expect(described_class).to receive(:postgresql?).and_return(true)
-
+    it 'returns correct value' do
       expect(described_class.false_value).to eq "'f'"
     end
-
-    it 'returns correct value for MySQL' do
-      expect(described_class).to receive(:postgresql?).and_return(false)
-
-      expect(described_class.false_value).to eq 0
-    end
   end
 
   describe '.read_only?' do
@@ -497,43 +430,33 @@ describe Gitlab::Database do
   end
 
   describe '.db_read_only?' do
-    context 'when using PostgreSQL' do
-      before do
-        allow(ActiveRecord::Base.connection).to receive(:execute).and_call_original
-        allow(described_class).to receive(:postgresql?).and_return(true)
-      end
-
-      it 'detects a read only database' do
-        allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => "t" }])
-
-        expect(described_class.db_read_only?).to be_truthy
-      end
+    before do
+      allow(ActiveRecord::Base.connection).to receive(:execute).and_call_original
+      allow(described_class).to receive(:postgresql?).and_return(true)
+    end
 
-      it 'detects a read only database' do
-        allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => true }])
+    it 'detects a read only database' do
+      allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => "t" }])
 
-        expect(described_class.db_read_only?).to be_truthy
-      end
+      expect(described_class.db_read_only?).to be_truthy
+    end
 
-      it 'detects a read write database' do
-        allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => "f" }])
+    it 'detects a read only database' do
+      allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => true }])
 
-        expect(described_class.db_read_only?).to be_falsey
-      end
+      expect(described_class.db_read_only?).to be_truthy
+    end
 
-      it 'detects a read write database' do
-        allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => false }])
+    it 'detects a read write database' do
+      allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => "f" }])
 
-        expect(described_class.db_read_only?).to be_falsey
-      end
+      expect(described_class.db_read_only?).to be_falsey
     end
 
-    context 'when using MySQL' do
-      before do
-        expect(described_class).to receive(:postgresql?).and_return(false)
-      end
+    it 'detects a read write database' do
+      allow(ActiveRecord::Base.connection).to receive(:execute).with('SELECT pg_is_in_recovery()').and_return([{ "pg_is_in_recovery" => false }])
 
-      it { expect(described_class.db_read_only?).to be_falsey }
+      expect(described_class.db_read_only?).to be_falsey
     end
   end
 
diff --git a/spec/lib/gitlab/import/database_helpers_spec.rb b/spec/lib/gitlab/import/database_helpers_spec.rb
index e716155b7d5..3ac34455177 100644
--- a/spec/lib/gitlab/import/database_helpers_spec.rb
+++ b/spec/lib/gitlab/import/database_helpers_spec.rb
@@ -15,32 +15,15 @@ describe Gitlab::Import::DatabaseHelpers do
     let(:attributes) { { iid: 1, title: 'foo' } }
     let(:project) { create(:project) }
 
-    context 'on PostgreSQL' do
-      it 'returns the ID returned by the query' do
-        expect(Gitlab::Database)
-          .to receive(:bulk_insert)
-          .with(Issue.table_name, [attributes], return_ids: true)
-          .and_return([10])
+    it 'returns the ID returned by the query' do
+      expect(Gitlab::Database)
+        .to receive(:bulk_insert)
+        .with(Issue.table_name, [attributes], return_ids: true)
+        .and_return([10])
 
-        id = subject.insert_and_return_id(attributes, project.issues)
+      id = subject.insert_and_return_id(attributes, project.issues)
 
-        expect(id).to eq(10)
-      end
-    end
-
-    context 'on MySQL' do
-      it 'uses a separate query to retrieve the ID' do
-        issue = create(:issue, project: project, iid: attributes[:iid])
-
-        expect(Gitlab::Database)
-          .to receive(:bulk_insert)
-          .with(Issue.table_name, [attributes], return_ids: true)
-          .and_return([])
-
-        id = subject.insert_and_return_id(attributes, project.issues)
-
-        expect(id).to eq(issue.id)
-      end
+      expect(id).to eq(10)
     end
   end
 end
diff --git a/spec/lib/serializers/json_spec.rb b/spec/lib/serializers/json_spec.rb
index 5d59d66e8b8..847a01d186c 100644
--- a/spec/lib/serializers/json_spec.rb
+++ b/spec/lib/serializers/json_spec.rb
@@ -6,24 +6,8 @@ describe Serializers::JSON do
 
     subject { described_class.dump(obj) }
 
-    context 'when MySQL is used' do
-      before do
-        allow(Gitlab::Database).to receive(:adapter_name) { 'mysql2' }
-      end
-
-      it 'encodes as string' do
-        is_expected.to eq('{"key":"value"}')
-      end
-    end
-
-    context 'when PostgreSQL is used' do
-      before do
-        allow(Gitlab::Database).to receive(:adapter_name) { 'postgresql' }
-      end
-
-      it 'returns a hash' do
-        is_expected.to eq(obj)
-      end
+    it 'returns a hash' do
+      is_expected.to eq(obj)
     end
   end
 
@@ -31,7 +15,13 @@ describe Serializers::JSON do
     let(:data_string) { '{"key":"value","variables":[{"key":"VAR1","value":"VALUE1"}]}' }
     let(:data_hash) { JSON.parse(data_string) }
 
-    shared_examples 'having consistent accessor' do
+    context 'when loading a hash' do
+      subject { described_class.load(data_hash) }
+
+      it 'decodes a string' do
+        is_expected.to be_a(Hash)
+      end
+
       it 'allows to access with symbols' do
         expect(subject[:key]).to eq('value')
         expect(subject[:variables].first[:key]).to eq('VAR1')
@@ -43,59 +33,11 @@ describe Serializers::JSON do
       end
     end
 
-    context 'when MySQL is used' do
-      before do
-        allow(Gitlab::Database).to receive(:adapter_name) { 'mysql2' }
-      end
-
-      context 'when loading a string' do
-        subject { described_class.load(data_string) }
-
-        it 'decodes a string' do
-          is_expected.to be_a(Hash)
-        end
-
-        it_behaves_like 'having consistent accessor'
-      end
-
-      context 'when loading a different type' do
-        subject { described_class.load({ key: 'hash' }) }
-
-        it 'raises an exception' do
-          expect { subject }.to raise_error(TypeError)
-        end
-      end
-
-      context 'when loading a nil' do
-        subject { described_class.load(nil) }
-
-        it 'returns nil' do
-          is_expected.to be_nil
-        end
-      end
-    end
-
-    context 'when PostgreSQL is used' do
-      before do
-        allow(Gitlab::Database).to receive(:adapter_name) { 'postgresql' }
-      end
-
-      context 'when loading a hash' do
-        subject { described_class.load(data_hash) }
-
-        it 'decodes a string' do
-          is_expected.to be_a(Hash)
-        end
-
-        it_behaves_like 'having consistent accessor'
-      end
-
-      context 'when loading a nil' do
-        subject { described_class.load(nil) }
+    context 'when loading a nil' do
+      subject { described_class.load(nil) }
 
-        it 'returns nil' do
-          is_expected.to be_nil
-        end
+      it 'returns nil' do
+        is_expected.to be_nil
       end
     end
   end
diff --git a/spec/models/concerns/case_sensitivity_spec.rb b/spec/models/concerns/case_sensitivity_spec.rb
index d6d41a25eac..9819f656f0d 100644
--- a/spec/models/concerns/case_sensitivity_spec.rb
+++ b/spec/models/concerns/case_sensitivity_spec.rb
@@ -28,28 +28,13 @@ describe CaseSensitivity do
         .to contain_exactly(model_1)
     end
 
-    # Using `mysql` & `postgresql` metadata-tags here because both adapters build
-    # the query slightly differently
-    context 'for MySQL', :mysql do
-      it 'builds a simple query' do
-        query = model.iwhere(path: %w(MODEL-1 model-2), name: 'model 1').to_sql
-        expected_query = <<~QRY.strip
-        SELECT `namespaces`.* FROM `namespaces` WHERE (`namespaces`.`path` IN ('MODEL-1', 'model-2')) AND (`namespaces`.`name` = 'model 1')
-        QRY
-
-        expect(query).to eq(expected_query)
-      end
-    end
+    it 'builds a query using LOWER' do
+      query = model.iwhere(path: %w(MODEL-1 model-2), name: 'model 1').to_sql
+      expected_query = <<~QRY.strip
+      SELECT \"namespaces\".* FROM \"namespaces\" WHERE (LOWER(\"namespaces\".\"path\") IN (LOWER('MODEL-1'), LOWER('model-2'))) AND (LOWER(\"namespaces\".\"name\") = LOWER('model 1'))
+      QRY
 
-    context 'for PostgreSQL', :postgresql do
-      it 'builds a query using LOWER' do
-        query = model.iwhere(path: %w(MODEL-1 model-2), name: 'model 1').to_sql
-        expected_query = <<~QRY.strip
-        SELECT \"namespaces\".* FROM \"namespaces\" WHERE (LOWER(\"namespaces\".\"path\") IN (LOWER('MODEL-1'), LOWER('model-2'))) AND (LOWER(\"namespaces\".\"name\") = LOWER('model 1'))
-        QRY
-
-        expect(query).to eq(expected_query)
-      end
+      expect(query).to eq(expected_query)
     end
   end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index a6fb172e79b..a44b5069ade 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -266,10 +266,6 @@ RSpec.configure do |config|
     example.run if Gitlab::Database.postgresql?
   end
 
-  config.around(:each, :mysql) do |example|
-    example.run if Gitlab::Database.mysql?
-  end
-
   # This makes sure the `ApplicationController#can?` method is stubbed with the
   # original implementation for all view specs.
   config.before(:each, type: :view) do
diff --git a/spec/workers/background_migration_worker_spec.rb b/spec/workers/background_migration_worker_spec.rb
index 746c858609f..e5be8ce0423 100644
--- a/spec/workers/background_migration_worker_spec.rb
+++ b/spec/workers/background_migration_worker_spec.rb
@@ -55,21 +55,13 @@ describe BackgroundMigrationWorker, :sidekiq, :clean_gitlab_redis_shared_state d
   end
 
   describe '#healthy_database?' do
-    context 'using MySQL', :mysql do
-      it 'returns true' do
-        expect(worker.healthy_database?).to eq(true)
-      end
-    end
-
-    context 'using PostgreSQL', :postgresql do
-      context 'when replication lag is too great' do
-        it 'returns false' do
-          allow(Postgresql::ReplicationSlot)
-            .to receive(:lag_too_great?)
-            .and_return(true)
+    context 'when replication lag is too great' do
+      it 'returns false' do
+        allow(Postgresql::ReplicationSlot)
+          .to receive(:lag_too_great?)
+          .and_return(true)
 
-          expect(worker.healthy_database?).to eq(false)
-        end
+        expect(worker.healthy_database?).to eq(false)
       end
 
       context 'when replication lag is small enough' do