Merge remote-tracking branch 'upstream/master' into 54953-error-500-viewing-merge-request-due-to-nil-commit_email_hostname

* upstream/master: (115 commits)
  [CE] Speed up login page usage
  Add new line and comments
  Fix the seeder 24_forks.rb cannot find public project
  Milestones on community contribution issues
  Removed Gitlab Upgrader found in /lib/gitlab/upgrader.rb
  Fix and move specs into admin_disables_git_access_protocol_spec.rb
  Fix HTTP/SSH clone panel for mobile
  Add spec for HTTP/SSH clone panel
  Fix missing Git clone button when protocol restriction setting enabled
  Fix deprecation: Using positional arguments in integration tests
  Extend override check to also check arity
  Update tm cli version
  Bump Gitaly version to v1.12.0
  Add @dbalexandre to CODEOWNERS
  Update verbiage for clarity
  Change group-cluster beta to regular note
  Change alpha states to use note instead of warning
  Update registry section. Update serverless.yaml formatting
  Clarify obtaining application URL
  Add @godfat to CODEOWNERS
  ...

10 files changed, 560 insertions, 66 deletions

diff --git a/spec/lib/gitlab/bare_repository_import/importer_spec.rb b/spec/lib/gitlab/bare_repository_import/importer_spec.rb
index 3c63e601abc..f4759b69538 100644
--- a/spec/lib/gitlab/bare_repository_import/importer_spec.rb
+++ b/spec/lib/gitlab/bare_repository_import/importer_spec.rb
@@ -192,7 +192,7 @@ describe Gitlab::BareRepositoryImport::Importer, :seed_helper do
     let(:project_path) { 'a-group/a-sub-group/a-project' }
 
     before do
-      expect(Group).to receive(:supports_nested_groups?) { false }
+      expect(Group).to receive(:supports_nested_objects?) { false }
     end
 
     describe '#create_project_if_needed' do
diff --git a/spec/lib/gitlab/gitaly_client_spec.rb b/spec/lib/gitlab/gitaly_client_spec.rb
index 5eda4d041a8..e41a75c37a7 100644
--- a/spec/lib/gitlab/gitaly_client_spec.rb
+++ b/spec/lib/gitlab/gitaly_client_spec.rb
@@ -3,6 +3,20 @@ require 'spec_helper'
 # We stub Gitaly in `spec/support/gitaly.rb` for other tests. We don't want
 # those stubs while testing the GitalyClient itself.
 describe Gitlab::GitalyClient do
+  let(:sample_cert) { Rails.root.join('spec/fixtures/clusters/sample_cert.pem').to_s }
+
+  before do
+    allow(described_class)
+      .to receive(:stub_cert_paths)
+      .and_return([sample_cert])
+  end
+
+  def stub_repos_storages(address)
+    allow(Gitlab.config.repositories).to receive(:storages).and_return({
+      'default' => { 'gitaly_address' => address }
+    })
+  end
+
   describe '.stub_class' do
     it 'returns the gRPC health check stub' do
       expect(described_class.stub_class(:health_check)).to eq(::Grpc::Health::V1::Health::Stub)
@@ -15,12 +29,8 @@ describe Gitlab::GitalyClient do
 
   describe '.stub_address' do
     it 'returns the same result after being called multiple times' do
-      address = 'localhost:9876'
-      prefixed_address = "tcp://#{address}"
-
-      allow(Gitlab.config.repositories).to receive(:storages).and_return({
-        'default' => { 'gitaly_address' => prefixed_address }
-      })
+      address = 'tcp://localhost:9876'
+      stub_repos_storages address
 
       2.times do
         expect(described_class.stub_address('default')).to eq('localhost:9876')
@@ -28,6 +38,45 @@ describe Gitlab::GitalyClient do
     end
   end
 
+  describe '.stub_certs' do
+    it 'skips certificates if OpenSSLError is raised and report it' do
+      expect(Rails.logger).to receive(:error).at_least(:once)
+      expect(Gitlab::Sentry)
+        .to receive(:track_exception)
+        .with(
+          a_kind_of(OpenSSL::X509::CertificateError),
+          extra: { cert_file: a_kind_of(String) }).at_least(:once)
+
+      expect(OpenSSL::X509::Certificate)
+        .to receive(:new)
+        .and_raise(OpenSSL::X509::CertificateError).at_least(:once)
+
+      expect(described_class.stub_certs).to be_a(String)
+    end
+  end
+  describe '.stub_creds' do
+    it 'returns :this_channel_is_insecure if unix' do
+      address = 'unix:/tmp/gitaly.sock'
+      stub_repos_storages address
+
+      expect(described_class.stub_creds('default')).to eq(:this_channel_is_insecure)
+    end
+
+    it 'returns :this_channel_is_insecure if tcp' do
+      address = 'tcp://localhost:9876'
+      stub_repos_storages address
+
+      expect(described_class.stub_creds('default')).to eq(:this_channel_is_insecure)
+    end
+
+    it 'returns Credentials object if tls' do
+      address = 'tls://localhost:9876'
+      stub_repos_storages address
+
+      expect(described_class.stub_creds('default')).to be_a(GRPC::Core::ChannelCredentials)
+    end
+  end
+
   describe '.stub' do
     # Notice that this is referring to gRPC "stubs", not rspec stubs
     before do
@@ -37,9 +86,19 @@ describe Gitlab::GitalyClient do
     context 'when passed a UNIX socket address' do
       it 'passes the address as-is to GRPC' do
         address = 'unix:/tmp/gitaly.sock'
-        allow(Gitlab.config.repositories).to receive(:storages).and_return({
-          'default' => { 'gitaly_address' => address }
-        })
+        stub_repos_storages address
+
+        expect(Gitaly::CommitService::Stub).to receive(:new).with(address, any_args)
+
+        described_class.stub(:commit_service, 'default')
+      end
+    end
+
+    context 'when passed a TLS address' do
+      it 'strips tls:// prefix before passing it to GRPC::Core::Channel initializer' do
+        address = 'localhost:9876'
+        prefixed_address = "tls://#{address}"
+        stub_repos_storages prefixed_address
 
         expect(Gitaly::CommitService::Stub).to receive(:new).with(address, any_args)
 
@@ -51,10 +110,7 @@ describe Gitlab::GitalyClient do
       it 'strips tcp:// prefix before passing it to GRPC::Core::Channel initializer' do
         address = 'localhost:9876'
         prefixed_address = "tcp://#{address}"
-
-        allow(Gitlab.config.repositories).to receive(:storages).and_return({
-          'default' => { 'gitaly_address' => prefixed_address }
-        })
+        stub_repos_storages prefixed_address
 
         expect(Gitaly::CommitService::Stub).to receive(:new).with(address, any_args)
 
diff --git a/spec/lib/gitlab/import_export/command_line_util_spec.rb b/spec/lib/gitlab/import_export/command_line_util_spec.rb
new file mode 100644
index 00000000000..8e5e0aefac0
--- /dev/null
+++ b/spec/lib/gitlab/import_export/command_line_util_spec.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::ImportExport::CommandLineUtil do
+  include ExportFileHelper
+
+  let(:path) { "#{Dir.tmpdir}/symlink_test" }
+  let(:archive) { 'spec/fixtures/symlink_export.tar.gz' }
+  let(:shared) { Gitlab::ImportExport::Shared.new(nil) }
+
+  subject do
+    Class.new do
+      include Gitlab::ImportExport::CommandLineUtil
+
+      def initialize
+        @shared = Gitlab::ImportExport::Shared.new(nil)
+      end
+    end.new
+  end
+
+  before do
+    FileUtils.mkdir_p(path)
+    subject.untar_zxf(archive: archive, dir: path)
+  end
+
+  after do
+    FileUtils.rm_rf(path)
+  end
+
+  it 'has the right mask for project.json' do
+    expect(file_permissions("#{path}/project.json")).to eq(0755) # originally 777
+  end
+
+  it 'has the right mask for uploads' do
+    expect(file_permissions("#{path}/uploads")).to eq(0755) # originally 555
+  end
+end
diff --git a/spec/lib/gitlab/import_export/file_importer_spec.rb b/spec/lib/gitlab/import_export/file_importer_spec.rb
index bf34cefe18f..fbc9bcd2df5 100644
--- a/spec/lib/gitlab/import_export/file_importer_spec.rb
+++ b/spec/lib/gitlab/import_export/file_importer_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Gitlab::ImportExport::FileImporter do
+  include ExportFileHelper
+
   let(:shared) { Gitlab::ImportExport::Shared.new(nil) }
   let(:storage_path) { "#{Dir.tmpdir}/file_importer_spec" }
   let(:valid_file) { "#{shared.export_path}/valid.json" }
@@ -8,6 +10,7 @@ describe Gitlab::ImportExport::FileImporter do
   let(:hidden_symlink_file) { "#{shared.export_path}/.hidden" }
   let(:subfolder_symlink_file) { "#{shared.export_path}/subfolder/invalid.json" }
   let(:evil_symlink_file) { "#{shared.export_path}/.\nevil" }
+  let(:custom_mode_symlink_file) { "#{shared.export_path}/symlink.mode" }
 
   before do
     stub_const('Gitlab::ImportExport::FileImporter::MAX_RETRIES', 0)
@@ -45,10 +48,18 @@ describe Gitlab::ImportExport::FileImporter do
       expect(File.exist?(subfolder_symlink_file)).to be false
     end
 
+    it 'removes symlinks without any file permissions' do
+      expect(File.exist?(custom_mode_symlink_file)).to be false
+    end
+
     it 'does not remove a valid file' do
       expect(File.exist?(valid_file)).to be true
     end
 
+    it 'does not change a valid file permissions' do
+      expect(file_permissions(valid_file)).not_to eq(0000)
+    end
+
     it 'creates the file in the right subfolder' do
       expect(shared.export_path).to include('test/abcd')
     end
@@ -84,5 +95,7 @@ describe Gitlab::ImportExport::FileImporter do
     FileUtils.ln_s(valid_file, subfolder_symlink_file)
     FileUtils.ln_s(valid_file, hidden_symlink_file)
     FileUtils.ln_s(valid_file, evil_symlink_file)
+    FileUtils.ln_s(valid_file, custom_mode_symlink_file)
+    FileUtils.chmod_R(0000, custom_mode_symlink_file)
   end
 end
diff --git a/spec/lib/gitlab/json_cache_spec.rb b/spec/lib/gitlab/json_cache_spec.rb
new file mode 100644
index 00000000000..b52078e8556
--- /dev/null
+++ b/spec/lib/gitlab/json_cache_spec.rb
@@ -0,0 +1,401 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::JsonCache do
+  let(:backend) { double('backend').as_null_object }
+  let(:namespace) { 'geo' }
+  let(:key) { 'foo' }
+  let(:expanded_key) { "#{namespace}:#{key}:#{Rails.version}" }
+  let(:broadcast_message) { create(:broadcast_message) }
+
+  subject(:cache) { described_class.new(namespace: namespace, backend: backend) }
+
+  describe '#active?' do
+    context 'when backend respond to active? method' do
+      it 'delegates to the underlying cache implementation' do
+        backend = double('backend', active?: false)
+
+        cache = described_class.new(namespace: namespace, backend: backend)
+
+        expect(cache.active?).to eq(false)
+      end
+    end
+
+    context 'when backend does not respond to active? method' do
+      it 'returns true' do
+        backend = double('backend')
+
+        cache = described_class.new(namespace: namespace, backend: backend)
+
+        expect(cache.active?).to eq(true)
+      end
+    end
+  end
+
+  describe '#cache_key' do
+    context 'when namespace is not defined' do
+      it 'expands out the key with Rails version' do
+        cache = described_class.new(cache_key_with_version: true)
+
+        cache_key = cache.cache_key(key)
+
+        expect(cache_key).to eq("#{key}:#{Rails.version}")
+      end
+    end
+
+    context 'when cache_key_with_version is true' do
+      it 'expands out the key with namespace and Rails version' do
+        cache = described_class.new(namespace: namespace, cache_key_with_version: true)
+
+        cache_key = cache.cache_key(key)
+
+        expect(cache_key).to eq("#{namespace}:#{key}:#{Rails.version}")
+      end
+    end
+
+    context 'when cache_key_with_version is false' do
+      it 'expands out the key with namespace' do
+        cache = described_class.new(namespace: namespace, cache_key_with_version: false)
+
+        cache_key = cache.cache_key(key)
+
+        expect(cache_key).to eq("#{namespace}:#{key}")
+      end
+    end
+
+    context 'when namespace is nil, and cache_key_with_version is false' do
+      it 'returns the key' do
+        cache = described_class.new(namespace: nil, cache_key_with_version: false)
+
+        cache_key = cache.cache_key(key)
+
+        expect(cache_key).to eq(key)
+      end
+    end
+  end
+
+  describe '#expire' do
+    it 'expires the given key from the cache' do
+      cache.expire(key)
+
+      expect(backend).to have_received(:delete).with(expanded_key)
+    end
+  end
+
+  describe '#read' do
+    it 'reads the given key from the cache' do
+      cache.read(key)
+
+      expect(backend).to have_received(:read).with(expanded_key)
+    end
+
+    it 'returns the cached value when there is data in the cache with the given key' do
+      allow(backend).to receive(:read)
+        .with(expanded_key)
+        .and_return("true")
+
+      expect(cache.read(key)).to eq(true)
+    end
+
+    it 'returns nil when there is no data in the cache with the given key' do
+      allow(backend).to receive(:read)
+        .with(expanded_key)
+        .and_return(nil)
+
+      expect(cache.read(key)).to be_nil
+    end
+
+    context 'when the cached value is a hash' do
+      it 'parses the cached value' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return(broadcast_message.to_json)
+
+        expect(cache.read(key, BroadcastMessage)).to eq(broadcast_message)
+      end
+
+      it 'returns nil when klass is nil' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return(broadcast_message.to_json)
+
+        expect(cache.read(key)).to be_nil
+      end
+
+      it 'gracefully handles bad cached entry' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return('{')
+
+        expect(cache.read(key, BroadcastMessage)).to be_nil
+      end
+
+      it 'gracefully handles an empty hash' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return('{}')
+
+        expect(cache.read(key, BroadcastMessage)).to be_a(BroadcastMessage)
+      end
+
+      it 'gracefully handles unknown attributes' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return(broadcast_message.attributes.merge(unknown_attribute: 1).to_json)
+
+        expect(cache.read(key, BroadcastMessage)).to be_nil
+      end
+    end
+
+    context 'when the cached value is an array' do
+      it 'parses the cached value' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return([broadcast_message].to_json)
+
+        expect(cache.read(key, BroadcastMessage)).to eq([broadcast_message])
+      end
+
+      it 'returns an empty array when klass is nil' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return([broadcast_message].to_json)
+
+        expect(cache.read(key)).to eq([])
+      end
+
+      it 'gracefully handles bad cached entry' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return('[')
+
+        expect(cache.read(key, BroadcastMessage)).to be_nil
+      end
+
+      it 'gracefully handles an empty array' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return('[]')
+
+        expect(cache.read(key, BroadcastMessage)).to eq([])
+      end
+
+      it 'gracefully handles unknown attributes' do
+        allow(backend).to receive(:read)
+          .with(expanded_key)
+          .and_return([{ unknown_attribute: 1 }, broadcast_message.attributes].to_json)
+
+        expect(cache.read(key, BroadcastMessage)).to eq([broadcast_message])
+      end
+    end
+  end
+
+  describe '#write' do
+    it 'writes value to the cache with the given key' do
+      cache.write(key, true)
+
+      expect(backend).to have_received(:write).with(expanded_key, "true", nil)
+    end
+
+    it 'writes a string containing a JSON representation of the value to the cache' do
+      cache.write(key, broadcast_message)
+
+      expect(backend).to have_received(:write)
+        .with(expanded_key, broadcast_message.to_json, nil)
+    end
+
+    it 'passes options the underlying cache implementation' do
+      cache.write(key, true, expires_in: 15.seconds)
+
+      expect(backend).to have_received(:write)
+        .with(expanded_key, "true", expires_in: 15.seconds)
+    end
+
+    it 'passes options the underlying cache implementation when options is empty' do
+      cache.write(key, true, {})
+
+      expect(backend).to have_received(:write)
+        .with(expanded_key, "true", {})
+    end
+
+    it 'passes options the underlying cache implementation when options is nil' do
+      cache.write(key, true, nil)
+
+      expect(backend).to have_received(:write)
+        .with(expanded_key, "true", nil)
+    end
+  end
+
+  describe '#fetch', :use_clean_rails_memory_store_caching do
+    let(:backend) { Rails.cache }
+
+    it 'requires a block' do
+      expect { cache.fetch(key) }.to raise_error(LocalJumpError)
+    end
+
+    it 'passes options the underlying cache implementation' do
+      expect(backend).to receive(:write)
+        .with(expanded_key, "true", expires_in: 15.seconds)
+
+      cache.fetch(key, expires_in: 15.seconds) { true }
+    end
+
+    context 'when the given key does not exist in the cache' do
+      context 'when the result of the block is truthy' do
+        it 'returns the result of the block' do
+          result = cache.fetch(key) { true }
+
+          expect(result).to eq(true)
+        end
+
+        it 'caches the value' do
+          expect(backend).to receive(:write).with(expanded_key, "true", {})
+
+          cache.fetch(key) { true }
+        end
+      end
+
+      context 'when the result of the block is false' do
+        it 'returns the result of the block' do
+          result = cache.fetch(key) { false }
+
+          expect(result).to eq(false)
+        end
+
+        it 'caches the value' do
+          expect(backend).to receive(:write).with(expanded_key, "false", {})
+
+          cache.fetch(key) { false }
+        end
+      end
+
+      context 'when the result of the block is nil' do
+        it 'returns the result of the block' do
+          result = cache.fetch(key) { nil }
+
+          expect(result).to eq(nil)
+        end
+
+        it 'caches the value' do
+          expect(backend).to receive(:write).with(expanded_key, "null", {})
+
+          cache.fetch(key) { nil }
+        end
+      end
+    end
+
+    context 'when the given key exists in the cache' do
+      context 'when the cached value is a hash' do
+        before do
+          backend.write(expanded_key, broadcast_message.to_json)
+        end
+
+        it 'parses the cached value' do
+          result = cache.fetch(key, as: BroadcastMessage) { 'block result' }
+
+          expect(result).to eq(broadcast_message)
+        end
+
+        it "returns the result of the block when 'as' option is nil" do
+          result = cache.fetch(key, as: nil) { 'block result' }
+
+          expect(result).to eq('block result')
+        end
+
+        it "returns the result of the block when 'as' option is not informed" do
+          result = cache.fetch(key) { 'block result' }
+
+          expect(result).to eq('block result')
+        end
+      end
+
+      context 'when the cached value is a array' do
+        before do
+          backend.write(expanded_key, [broadcast_message].to_json)
+        end
+
+        it 'parses the cached value' do
+          result = cache.fetch(key, as: BroadcastMessage) { 'block result' }
+
+          expect(result).to eq([broadcast_message])
+        end
+
+        it "returns an empty array when 'as' option is nil" do
+          result = cache.fetch(key, as: nil) { 'block result' }
+
+          expect(result).to eq([])
+        end
+
+        it "returns an empty array when 'as' option is not informed" do
+          result = cache.fetch(key) { 'block result' }
+
+          expect(result).to eq([])
+        end
+      end
+
+      context 'when the cached value is true' do
+        before do
+          backend.write(expanded_key, "true")
+        end
+
+        it 'returns the cached value' do
+          result = cache.fetch(key) { 'block result' }
+
+          expect(result).to eq(true)
+        end
+
+        it 'does not execute the block' do
+          expect { |block| cache.fetch(key, &block) }.not_to yield_control
+        end
+
+        it 'does not write to the cache' do
+          expect(backend).not_to receive(:write)
+
+          cache.fetch(key) { 'block result' }
+        end
+      end
+
+      context 'when the cached value is false' do
+        before do
+          backend.write(expanded_key, "false")
+        end
+
+        it 'returns the cached value' do
+          result = cache.fetch(key) { 'block result' }
+
+          expect(result).to eq(false)
+        end
+
+        it 'does not execute the block' do
+          expect { |block| cache.fetch(key, &block) }.not_to yield_control
+        end
+
+        it 'does not write to the cache' do
+          expect(backend).not_to receive(:write)
+
+          cache.fetch(key) { 'block result' }
+        end
+      end
+
+      context 'when the cached value is nil' do
+        before do
+          backend.write(expanded_key, "null")
+        end
+
+        it 'returns the result of the block' do
+          result = cache.fetch(key) { 'block result' }
+
+          expect(result).to eq('block result')
+        end
+
+        it 'writes the result of the block to the cache' do
+          expect(backend).to receive(:write)
+            .with(expanded_key, 'block result'.to_json, {})
+
+          cache.fetch(key) { 'block result' }
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/group_hierarchy_spec.rb b/spec/lib/gitlab/object_hierarchy_spec.rb
index f3de7adcec7..4700a7ad2e1 100644
--- a/spec/lib/gitlab/group_hierarchy_spec.rb
+++ b/spec/lib/gitlab/object_hierarchy_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GroupHierarchy, :postgresql do
+describe Gitlab::ObjectHierarchy, :postgresql do
   let!(:parent) { create(:group) }
   let!(:child1) { create(:group, parent: parent) }
   let!(:child2) { create(:group, parent: child1) }
@@ -105,9 +105,9 @@ describe Gitlab::GroupHierarchy, :postgresql do
     end
   end
 
-  describe '#all_groups' do
+  describe '#all_objects' do
     let(:relation) do
-      described_class.new(Group.where(id: child1.id)).all_groups
+      described_class.new(Group.where(id: child1.id)).all_objects
     end
 
     it 'includes the base rows' do
@@ -123,13 +123,13 @@ describe Gitlab::GroupHierarchy, :postgresql do
     end
 
     it 'uses ancestors_base #initialize argument for ancestors' do
-      relation = described_class.new(Group.where(id: child1.id), Group.where(id: Group.maximum(:id).succ)).all_groups
+      relation = described_class.new(Group.where(id: child1.id), Group.where(id: Group.maximum(:id).succ)).all_objects
 
       expect(relation).to include(parent)
     end
 
     it 'uses descendants_base #initialize argument for descendants' do
-      relation = described_class.new(Group.where(id: Group.maximum(:id).succ), Group.where(id: child1.id)).all_groups
+      relation = described_class.new(Group.where(id: Group.maximum(:id).succ), Group.where(id: child1.id)).all_objects
 
       expect(relation).to include(child2)
     end
diff --git a/spec/lib/gitlab/project_authorizations_spec.rb b/spec/lib/gitlab/project_authorizations_spec.rb
index 00c62c7bf96..bd0bc2c9044 100644
--- a/spec/lib/gitlab/project_authorizations_spec.rb
+++ b/spec/lib/gitlab/project_authorizations_spec.rb
@@ -20,7 +20,7 @@ describe Gitlab::ProjectAuthorizations do
   end
 
   let(:authorizations) do
-    klass = if Group.supports_nested_groups?
+    klass = if Group.supports_nested_objects?
               Gitlab::ProjectAuthorizations::WithNestedGroups
             else
               Gitlab::ProjectAuthorizations::WithoutNestedGroups
@@ -46,7 +46,7 @@ describe Gitlab::ProjectAuthorizations do
     expect(mapping[group_project.id]).to eq(Gitlab::Access::DEVELOPER)
   end
 
-  if Group.supports_nested_groups?
+  if Group.supports_nested_objects?
     context 'with nested groups' do
       let!(:nested_group) { create(:group, parent: group) }
       let!(:nested_project) { create(:project, namespace: nested_group) }
diff --git a/spec/lib/gitlab/prometheus/query_variables_spec.rb b/spec/lib/gitlab/prometheus/query_variables_spec.rb
index 78974cadb69..78c74266c61 100644
--- a/spec/lib/gitlab/prometheus/query_variables_spec.rb
+++ b/spec/lib/gitlab/prometheus/query_variables_spec.rb
@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Gitlab::Prometheus::QueryVariables do
   describe '.call' do
-    set(:environment) { create(:environment) }
+    let(:environment) { create(:environment) }
     let(:slug) { environment.slug }
 
     subject { described_class.call(environment) }
@@ -20,7 +20,7 @@ describe Gitlab::Prometheus::QueryVariables do
       it { is_expected.to include(kube_namespace: '') }
     end
 
-    context 'with deplyoment platform' do
+    context 'with deployment platform' do
       let(:kube_namespace) { environment.deployment_platform.actual_namespace }
 
       before do
diff --git a/spec/lib/gitlab/upgrader_spec.rb b/spec/lib/gitlab/upgrader_spec.rb
deleted file mode 100644
index 6106f13c774..00000000000
--- a/spec/lib/gitlab/upgrader_spec.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Gitlab::Upgrader do
-  let(:upgrader) { described_class.new }
-  let(:current_version) { Gitlab::VERSION }
-
-  describe 'current_version_raw' do
-    it { expect(upgrader.current_version_raw).to eq(current_version) }
-  end
-
-  describe 'latest_version?' do
-    it 'is true if newest version' do
-      allow(upgrader).to receive(:latest_version_raw).and_return(current_version)
-      expect(upgrader.latest_version?).to be_truthy
-    end
-  end
-
-  describe 'latest_version_raw' do
-    it 'is the latest version for GitLab 5' do
-      allow(upgrader).to receive(:current_version_raw).and_return("5.3.0")
-      expect(upgrader.latest_version_raw).to eq("v5.4.2")
-    end
-
-    it 'gets the latest version from tags' do
-      allow(upgrader).to receive(:fetch_git_tags).and_return([
-        '6f0733310546402c15d3ae6128a95052f6c8ea96  refs/tags/v7.1.1',
-        'facfec4b242ce151af224e20715d58e628aa5e74  refs/tags/v7.1.1^{}',
-        'f7068d99c79cf79befbd388030c051bb4b5e86d4  refs/tags/v7.10.4',
-        '337225a4fcfa9674e2528cb6d41c46556bba9dfa  refs/tags/v7.10.4^{}',
-        '880e0ba0adbed95d087f61a9a17515e518fc6440  refs/tags/v7.11.1',
-        '6584346b604f981f00af8011cd95472b2776d912  refs/tags/v7.11.1^{}',
-        '43af3e65a486a9237f29f56d96c3b3da59c24ae0  refs/tags/v7.11.2',
-        'dac18e7728013a77410e926a1e64225703754a2d  refs/tags/v7.11.2^{}',
-        '0bf21fd4b46c980c26fd8c90a14b86a4d90cc950  refs/tags/v7.9.4',
-        'b10de29edbaff7219547dc506cb1468ee35065c3  refs/tags/v7.9.4^{}'
-      ])
-      expect(upgrader.latest_version_raw).to eq("v7.11.2")
-    end
-  end
-end
diff --git a/spec/lib/gitlab/utils/override_spec.rb b/spec/lib/gitlab/utils/override_spec.rb
index fc08ebcfc6d..9e7c97f8095 100644
--- a/spec/lib/gitlab/utils/override_spec.rb
+++ b/spec/lib/gitlab/utils/override_spec.rb
@@ -25,11 +25,21 @@ describe Gitlab::Utils::Override do
 
   let(:klass) { subject }
 
-  def good(mod)
+  def good(mod, bad_arity: false, negative_arity: false)
     mod.module_eval do
       override :good
-      def good
-        super.succ
+
+      if bad_arity
+        def good(num)
+        end
+      elsif negative_arity
+        def good(*args)
+          super.succ
+        end
+      else
+        def good
+          super.succ
+        end
       end
     end
 
@@ -56,6 +66,14 @@ describe Gitlab::Utils::Override do
       described_class.verify!
     end
 
+    it 'checks ok for overriding method using negative arity' do
+      good(subject, negative_arity: true)
+      result = instance.good
+
+      expect(result).to eq(1)
+      described_class.verify!
+    end
+
     it 'raises NotImplementedError when it is not overriding anything' do
       expect do
         bad(subject)
@@ -63,6 +81,14 @@ describe Gitlab::Utils::Override do
         described_class.verify!
       end.to raise_error(NotImplementedError)
     end
+
+    it 'raises NotImplementedError when overriding a method with different arity' do
+      expect do
+        good(subject, bad_arity: true)
+        instance.good(1)
+        described_class.verify!
+      end.to raise_error(NotImplementedError)
+    end
   end
 
   shared_examples 'checking as intended, nothing was overridden' do