Merge branch 'extract-ee-specific-code-for-spec/support' into 'master'

[EE] Extract EE-specific code for spec/support

See merge request gitlab-org/gitlab-ee!9724

ee/spec/lib/gitlab/prometheus/queries/additional_metrics_deployment_query_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Prometheus::Queries::AdditionalMetricsDeploymentQuery do
+  around do |example|
+    Timecop.freeze(Time.local(2008, 9, 1, 12, 0, 0)) { example.run }
+  end
+
+  include_examples 'additional custom metrics query' do
+    let(:deployment) { create(:deployment, environment: environment) }
+    let(:query_params) { [deployment.id] }
+
+    it 'queries using specific time' do
+      expect(client).to receive(:query_range).with(anything,
+                                                   start: (deployment.created_at - 30.minutes).to_f,
+                                                   stop: (deployment.created_at + 30.minutes).to_f)
+
+      expect(query_result).not_to be_nil
+    end
+  end
+end

ee/spec/lib/gitlab/prometheus/queries/additional_metrics_environment_query_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Prometheus::Queries::AdditionalMetricsEnvironmentQuery do
+  around do |example|
+    Timecop.freeze { example.run }
+  end
+
+  include_examples 'additional custom metrics query' do
+    let(:query_params) { [environment.id] }
+
+    it 'queries using specific time' do
+      expect(client).to receive(:query_range).with(anything, start: 8.hours.ago.to_f, stop: Time.now.to_f)
+
+      expect(query_result).not_to be_nil
+    end
+  end
+end

ee/spec/models/commit_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Commit do
+  it_behaves_like 'a mentionable with EE-specific mentions' do
+    subject { create(:project, :repository).commit }
+
+    let(:author) { create(:user, email: subject.author_email) }
+    let(:backref_text) { "commit #{subject.id}" }
+    let(:set_mentionable_text) do
+      ->(txt) { allow(subject).to receive(:safe_message).and_return(txt) }
+    end
+
+    # Include the subject in the repository stub.
+    let(:extra_commits) { [subject] }
+  end
+end

ee/spec/models/issue_spec.rb

@@ -27,6 +27,13 @@ describe Issue do
     end
   end
 
+  it_behaves_like 'an editable mentionable with EE-specific mentions' do
+    subject { create(:issue, project: create(:project, :repository)) }
+
+    let(:backref_text) { "issue #{subject.to_reference}" }
+    let(:set_mentionable_text) { ->(txt) { subject.description = txt } }
+  end
+
   describe '#related_issues' do
     let(:user) { create(:user) }
     let(:authorized_project) { create(:project) }

ee/spec/models/merge_request_spec.rb

@@ -17,6 +17,13 @@ describe MergeRequest do
     it { is_expected.to have_many(:approved_by_users) }
   end
 
+  it_behaves_like 'an editable mentionable with EE-specific mentions' do
+    subject { create(:merge_request, :simple) }
+
+    let(:backref_text) { "merge request #{subject.to_reference}" }
+    let(:set_mentionable_text) { ->(txt) { subject.description = txt } }
+  end
+
   describe 'approval_rules' do
     context 'when project contains approval_rules' do
       let!(:project_rule1) {  project.approval_rules.create(name: 'p1') }

ee/spec/models/note_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Note do
+  it_behaves_like 'an editable mentionable with EE-specific mentions' do
+    subject { create :note, noteable: issue, project: issue.project }
+
+    let(:issue) { create(:issue, project: create(:project, :repository)) }
+    let(:backref_text) { issue.gfm_reference }
+    let(:set_mentionable_text) { ->(txt) { subject.note = txt } }
+  end
+end

ee/spec/requests/api/group_milestones_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe API::GroupMilestones do
+  let(:user) { create(:user) }
+  let(:group) { create(:group, :private) }
+  let(:project) { create(:project, namespace: group) }
+  let!(:group_member) { create(:group_member, group: group, user: user) }
+  let!(:closed_milestone) { create(:closed_milestone, group: group, title: 'version1', description: 'closed milestone') }
+  let!(:milestone) { create(:milestone, group: group, title: 'version2', description: 'open milestone') }
+  let(:issues_route) { "/groups/#{group.id}/milestones/#{milestone.id}/issues" }
+
+  before do
+    project.add_developer(user)
+    milestone.issues << create(:issue, project: project)
+  end
+
+  it 'matches V4 EE-specific  response schema for a list of issues' do
+    get api(issues_route, user)
+
+    expect(response).to have_gitlab_http_status(200)
+    expect(response).to match_response_schema('public_api/v4/issues', dir: 'ee')
+  end
+end

ee/spec/requests/api/project_milestones_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe API::ProjectMilestones do
+  let(:user) { create(:user) }
+  let!(:project) { create(:project, namespace: user.namespace ) }
+  let!(:milestone) { create(:milestone, project: project, title: 'version2', description: 'open milestone') }
+  let(:issues_route) { "/projects/#{project.id}/milestones/#{milestone.id}/issues" }
+
+  before do
+    project.add_developer(user)
+    milestone.issues << create(:issue, project: project)
+  end
+
+  it 'matches V4 EE-specific response schema for a list of issues' do
+    get api(issues_route, user)
+
+    expect(response).to have_gitlab_http_status(200)
+    expect(response).to match_response_schema('public_api/v4/issues', dir: 'ee')
+  end
+end

ee/spec/support/db_cleaner.rb

+# frozen_string_literal: true
+
+module EE
+  module DbCleaner
+    extend ::Gitlab::Utils::Override
+
+    override :deletion_except_tables
+    def deletion_except_tables
+      super << 'licenses'
+    end
+
+    override :setup_database_cleaner
+    def setup_database_cleaner
+      if ::Gitlab::Geo.geo_database_configured?
+        ::DatabaseCleaner[:active_record, { connection: ::Geo::BaseRegistry }]
+      end
+
+      super
+    end
+  end
+end

ee/spec/support/helpers/ee/ldap_helpers.rb

@@ -4,6 +4,12 @@ module EE
       EE::Gitlab::Auth::LDAP::Sync::Proxy.new(provider, adapter)
     end
 
+    def fake_ldap_sync_proxy(provider)
+      fake_proxy = double(:proxy, adapter: ldap_adapter)
+      allow(::EE::Gitlab::Auth::LDAP::Sync::Proxy).to receive(:open).with(provider).and_yield(fake_proxy)
+      fake_proxy
+    end
+
     # Stub an LDAP group search and provide the return entry. Specify `nil` for
     # `entry` to simulate when an LDAP group is not found
     #

ee/spec/support/helpers/ee/stub_configuration.rb

+# frozen_string_literal: true
+
 module EE
   module StubConfiguration
     def stub_ee_application_setting(messages)
@@ -12,5 +14,15 @@ module EE
       # Ensure that we don't use the Markdown cache when stubbing these values
       allow_any_instance_of(EE::ApplicationSetting).to receive(:cached_html_up_to_date?).and_return(false)
     end
+
+    def stub_application_setting_on_object(object, messages)
+      add_predicates(messages)
+
+      allow(::Gitlab::CurrentSettings.current_application_settings)
+        .to receive_messages(messages)
+      messages.each do |setting, value|
+        allow(object).to receive_message_chain(:current_application_settings, setting) { value }
+      end
+    end
   end
 end

ee/spec/support/helpers/ee/stub_object_storage.rb

@@ -7,5 +7,10 @@ module EE
                                    remote_directory: 'packages',
                                    **params)
     end
+
+    def stub_object_storage_pseudonymizer
+      stub_object_storage(connection_params: Pseudonymizer::Uploader.object_store_credentials,
+                          remote_directory: Pseudonymizer::Uploader.remote_directory)
+    end
   end
 end

ee/spec/support/matchers/ee/markdown_matchers.rb

+# frozen_string_literal: true
+
+module EE
+  module MarkdownMatchers
+    extend RSpec::Matchers::DSL
+    include Capybara::Node::Matchers
+
+    # EpicReferenceFilter
+    matcher :reference_epics do
+      set_default_markdown_messages
+
+      match do |actual|
+        expect(actual).to have_selector('a.gfm.gfm-epic', count: 5)
+      end
+    end
+  end
+end

ee/spec/support/prometheus/additional_metrics_shared_examples.rb

+# frozen_string_literal: true
+
+RSpec.shared_examples 'additional custom metrics query' do
+  include Prometheus::MetricBuilders
+
+  let(:metric_group_class) { Gitlab::Prometheus::MetricGroup }
+  let(:metric_class) { Gitlab::Prometheus::Metric }
+
+  let(:metric_names) { %w{metric_a metric_b} }
+
+  let(:query_range_result) do
+    [{ 'metric': {}, 'values': [[1488758662.506, '0.00002996364761904785'], [1488758722.506, '0.00003090239047619091']] }]
+  end
+
+  let(:client) { double('prometheus_client') }
+  let(:query_result) { described_class.new(client).query(*query_params) }
+  let(:project) { create(:project) }
+  let(:environment) { create(:environment, slug: 'environment-slug', project: project) }
+
+  before do
+    allow(client).to receive(:label_values).and_return(metric_names)
+    allow(metric_group_class).to receive(:common_metrics).and_return([simple_metric_group(metrics: [simple_metric])])
+  end
+
+  context 'with custom metrics' do
+    let!(:metric) { create(:prometheus_metric, project: project) }
+    before do
+      allow(client).to receive(:query_range).with('avg(metric)', any_args).and_return(query_range_result)
+    end
+
+    context 'without common metrics' do
+      before do
+        allow(metric_group_class).to receive(:common_metrics).and_return([])
+      end
+
+      it 'return group data for custom metric' do
+        queries_with_result = { queries: [{ query_range: 'avg(metric)', unit: 'm/s', label: 'legend', result: query_range_result }] }
+        expect(query_result).to match_schema('prometheus/additional_metrics_query_result')
+
+        expect(query_result.count).to eq(1)
+        expect(query_result.first[:metrics].count).to eq(1)
+
+        expect(query_result.first[:metrics].first).to include(queries_with_result)
+      end
+    end
+
+    context 'with common metrics' do
+      before do
+        allow(client).to receive(:query_range).with('query_range_a', any_args).and_return(query_range_result)
+
+        allow(metric_group_class).to receive(:common_metrics).and_return([simple_metric_group(metrics: [simple_metric])])
+      end
+
+      it 'return group data for custom metric' do
+        custom_queries_with_result = { queries: [{ query_range: 'avg(metric)', unit: 'm/s', label: 'legend', result: query_range_result }] }
+        common_queries_with_result = { queries: [{ query_range: 'query_range_a', result: query_range_result }] }
+
+        expect(query_result).to match_schema('prometheus/additional_metrics_query_result')
+
+        expect(query_result.count).to eq(2)
+        expect(query_result).to all(satisfy { |r| r[:metrics].count == 1 })
+
+        expect(query_result[0][:metrics].first).to include(common_queries_with_result)
+        expect(query_result[1][:metrics].first).to include(custom_queries_with_result)
+      end
+    end
+  end
+end

ee/spec/support/shared_examples/mentionable_shared_examples.rb

+# frozen_string_literal: true
+
+# Specifications for behavior common to all Mentionable implementations.
+# Requires a shared context containing:
+# - subject { "the mentionable implementation" }
+# - let(:backref_text) { "the way that +subject+ should refer to itself in backreferences " }
+# - let(:set_mentionable_text) { lambda { |txt| "block that assigns txt to the subject's mentionable_text" } }
+
+shared_context 'mentionable context with EE-specific mentions' do
+  let(:group) { create(:group) }
+  let(:mentioned_epic) { create(:epic, group: group) }
+  let(:ref_string) do
+    <<-MSG.strip_heredoc
+      These references are new:
+        Epic:  #{mentioned_epic.to_reference(project)}
+    MSG
+  end
+
+  before do
+    stub_licensed_features(epics: true)
+  end
+end
+
+shared_examples 'a mentionable with EE-specific mentions' do
+  include_context 'mentionable context'
+  include_context 'mentionable context with EE-specific mentions'
+
+  it "extracts references from its reference property" do
+    # De-duplicate and omit itself
+    refs = subject.referenced_mentionables
+
+    expect(refs.size).to eq(1)
+    expect(refs).to include(mentioned_epic)
+  end
+
+  it 'creates cross-reference notes' do
+    mentioned_objects = [mentioned_epic]
+
+    mentioned_objects.each do |referenced|
+      expect(SystemNoteService).to receive(:cross_reference)
+        .with(referenced, subject.local_reference, author)
+    end
+
+    subject.create_cross_references!
+  end
+end
+
+shared_examples 'an editable mentionable with EE-specific mentions' do
+  include_context 'mentionable context'
+  include_context 'mentionable context with EE-specific mentions'
+
+  it_behaves_like 'a mentionable with EE-specific mentions'
+
+  let(:new_epic) { create(:epic, group: group) }
+
+  it 'creates new cross-reference notes when the mentionable text is edited' do
+    subject.save
+    subject.create_cross_references!
+
+    new_text = <<-MSG.strip_heredoc
+      These references already existed:
+
+      Issue:  #{mentioned_epic.to_reference(project)}
+
+      ---
+
+      This reference are introduced in an edit:
+
+      Epic: #{new_epic.to_reference(project)}
+    MSG
+
+    # These four objects were already referenced, and should not receive new
+    # notes
+    [mentioned_epic].each do |oldref|
+      expect(SystemNoteService).not_to receive(:cross_reference)
+        .with(oldref, any_args)
+    end
+
+    # These two issues and an epic are new and should receive reference notes
+    # In the case of MergeRequests remember that cannot mention commits included in the MergeRequest
+    [new_epic].each do |newref|
+      expect(SystemNoteService).to receive(:cross_reference)
+        .with(newref, subject.local_reference, author)
+    end
+
+    set_mentionable_text.call(new_text)
+    subject.create_new_cross_references!(author)
+  end
+end

spec/support/api/milestones_shared_examples.rb

@@ -240,7 +240,7 @@ shared_examples_for 'group and project milestones' do |route_definition|
       get api(issues_route, user)
 
       expect(response).to have_gitlab_http_status(200)
-      expect(response).to match_response_schema('public_api/v4/issues', dir: 'ee')
+      expect(response).to match_response_schema('public_api/v4/issues')
     end
 
     it 'returns a 401 error if user not authenticated' do

spec/support/database_cleaner.rb

+# frozen_string_literal: true
+
+require 'database_cleaner/active_record/deletion'
+require_relative 'db_cleaner'
+
+module FakeInformationSchema
+  # Work around a bug in DatabaseCleaner when using the deletion strategy:
+  # https://github.com/DatabaseCleaner/database_cleaner/issues/347
+  #
+  # On MySQL, if the information schema is said to exist, we use an inaccurate
+  # row count leading to some tables not being cleaned when they should
+  def information_schema_exists?(_connection)
+    false
+  end
+end
+
+DatabaseCleaner::ActiveRecord::Deletion.prepend(FakeInformationSchema)
+
+RSpec.configure do |config|
+  include DbCleaner
+
+  # Ensure all sequences are reset at the start of the suite run
+  config.before(:suite) do
+    setup_database_cleaner
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.append_after(:context) do
+    DatabaseCleaner.clean_with(:deletion, cache_tables: false)
+  end
+
+  config.before do
+    setup_database_cleaner
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before(:each, :js) do
+    DatabaseCleaner.strategy = :deletion, { except: deletion_except_tables, cache_tables: false }
+  end
+
+  config.before(:each, :delete) do
+    DatabaseCleaner.strategy = :deletion, { except: deletion_except_tables, cache_tables: false }
+  end
+
+  config.before(:each, :migration) do
+    DatabaseCleaner.strategy = :deletion, { cache_tables: false }
+  end
+
+  config.before do
+    DatabaseCleaner.start
+  end
+
+  config.append_after do
+    DatabaseCleaner.clean
+  end
+end

spec/support/db_cleaner.rb

-require 'database_cleaner/active_record/deletion'
-
-module FakeInformationSchema
-  # Work around a bug in DatabaseCleaner when using the deletion strategy:
-  # https://github.com/DatabaseCleaner/database_cleaner/issues/347
-  #
-  # On MySQL, if the information schema is said to exist, we use an inaccurate
-  # row count leading to some tables not being cleaned when they should
-  def information_schema_exists?(_connection)
-    false
-  end
-end
-
-DatabaseCleaner::ActiveRecord::Deletion.prepend(FakeInformationSchema)
-
-RSpec.configure do |config|
-  # Ensure all sequences are reset at the start of the suite run
-  config.before(:suite) do
-    setup_database_cleaner
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
-  config.append_after(:context) do
-    DatabaseCleaner.clean_with(:deletion, cache_tables: false)
-  end
-
-  config.before do
-    setup_database_cleaner
-    DatabaseCleaner.strategy = :transaction
-  end
-
-  config.before(:each, :js) do
-    DatabaseCleaner.strategy = :deletion, { except: %w[licenses], cache_tables: false }
-  end
-
-  config.before(:each, :delete) do
-    DatabaseCleaner.strategy = :deletion, { except: %w[licenses], cache_tables: false }
-  end
-
-  config.before(:each, :migration) do
-    DatabaseCleaner.strategy = :deletion, { cache_tables: false }
-  end
-
-  config.before do
-    DatabaseCleaner.start
-  end
-
-  config.append_after do
-    DatabaseCleaner.clean
+module DbCleaner
+  def deletion_except_tables
+    []
   end
 
   def setup_database_cleaner
-    if Gitlab::Geo.geo_database_configured?
-      DatabaseCleaner[:active_record, { connection: Geo::BaseRegistry }]
-    end
-
     DatabaseCleaner[:active_record, { connection: ActiveRecord::Base }]
   end
 end
+
+DbCleaner.prepend(EE::DbCleaner)

spec/support/helpers/javascript_fixtures_helpers.rb

@@ -2,11 +2,12 @@ require 'action_dispatch/testing/test_request'
 require 'fileutils'
 
 module JavaScriptFixturesHelpers
+  extend ActiveSupport::Concern
   include Gitlab::Popen
 
   FIXTURE_PATHS = %w[spec/javascripts/fixtures ee/spec/javascripts/fixtures].freeze
 
-  def self.included(base)
+  included do |base|
     base.around do |example|
       # pick an arbitrary date from the past, so tests are not time dependent
       Timecop.freeze(Time.utc(2015, 7, 3, 10)) { example.run }

spec/support/helpers/ldap_helpers.rb

 module LdapHelpers
-  include EE::LdapHelpers
-
   def ldap_adapter(provider = 'ldapmain', ldap = double(:ldap))
     ::Gitlab::Auth::LDAP::Adapter.new(provider, ldap)
   end
 
-  def fake_ldap_sync_proxy(provider)
-    fake_proxy = double(:proxy, adapter: ldap_adapter)
-    allow(::EE::Gitlab::Auth::LDAP::Sync::Proxy).to receive(:open).with(provider).and_yield(fake_proxy)
-    fake_proxy
-  end
-
   def user_dn(uid)
     "uid=#{uid},ou=users,dc=example,dc=com"
   end
@@ -76,3 +68,5 @@ module LdapHelpers
       .to receive(:ldap_search).and_raise(Gitlab::Auth::LDAP::LDAPConnectionError)
   end
 end
+
+LdapHelpers.include(EE::LdapHelpers)

spec/support/helpers/migrations_helpers.rb

 module MigrationsHelpers
-  prepend EE::MigrationsHelpers
-
   def active_record_base
     ActiveRecord::Base
   end
@@ -130,3 +128,5 @@ module MigrationsHelpers
     end
   end
 end
+
+MigrationsHelpers.prepend(EE::MigrationsHelpers)

spec/support/helpers/stub_configuration.rb

@@ -4,11 +4,7 @@ require 'active_support/dependencies'
 
 require_dependency 'gitlab'
 
-require_dependency Gitlab.root.join('ee/spec/support/helpers/ee/stub_configuration')
-
 module StubConfiguration
-  prepend EE::StubConfiguration
-
   def stub_application_setting(messages)
     add_predicates(messages)
 
@@ -22,16 +18,6 @@ module StubConfiguration
     allow_any_instance_of(ApplicationSetting).to receive(:cached_html_up_to_date?).and_return(false)
   end
 
-  def stub_application_setting_on_object(object, messages)
-    add_predicates(messages)
-
-    allow(Gitlab::CurrentSettings.current_application_settings)
-      .to receive_messages(messages)
-    messages.each do |setting, value|
-      allow(object).to receive_message_chain(:current_application_settings, setting) { value }
-    end
-  end
-
   def stub_not_protect_default_branch
     stub_application_setting(
       default_branch_protection: Gitlab::Access::PROTECTION_NONE)
@@ -130,3 +116,5 @@ module StubConfiguration
     end
   end
 end
+
+StubConfiguration.prepend(EE::StubConfiguration)

spec/support/helpers/stub_gitlab_calls.rb

 module StubGitlabCalls
-  prepend EE::StubGitlabCalls
-
   def stub_gitlab_calls
     stub_user
     stub_project_8
@@ -135,3 +133,5 @@ module StubGitlabCalls
     JSON.parse f
   end
 end
+
+StubGitlabCalls.prepend(EE::StubGitlabCalls)

spec/support/helpers/stub_object_storage.rb

-require_relative '../../../ee/spec/support/helpers/ee/stub_object_storage'
-
 module StubObjectStorage
-  prepend EE::StubObjectStorage
-
   def stub_object_storage_uploader(
         config:,
         uploader:,
@@ -78,9 +74,6 @@ module StubObjectStorage
         </InitiateMultipartUploadResult>
       EOS
   end
-
-  def stub_object_storage_pseudonymizer
-    stub_object_storage(connection_params: Pseudonymizer::Uploader.object_store_credentials,
-                        remote_directory: Pseudonymizer::Uploader.remote_directory)
-  end
 end
+
+StubObjectStorage.prepend(EE::StubObjectStorage)

spec/support/matchers/access_matchers.rb

@@ -7,31 +7,28 @@ module AccessMatchers
   extend RSpec::Matchers::DSL
   include Warden::Test::Helpers
 
-  def emulate_user(user, membership = nil)
-    case user
-    when :user
-      login_as(create(:user))
+  def emulate_user(user_type_or_trait, membership = nil)
+    case user_type_or_trait
+    when :user, :admin
+      login_as(create(user_type_or_trait))
+    when :external, :auditor
+      login_as(create(:user, user_type_or_trait))
     when :visitor
       logout
-    when :admin
-      login_as(create(:admin))
-    when :auditor
-      login_as(create(:user, :auditor))
-    when :external
-      login_as(create(:user, external: true))
     when User
-      login_as(user)
+      login_as(user_type_or_trait)
     when *Gitlab::Access.sym_options_with_owner.keys
-      raise ArgumentError, "cannot emulate #{user} without membership parent" unless membership
-
-      role = user
+      raise ArgumentError, "cannot emulate #{user_type_or_trait} without membership parent" unless membership
 
-      if role == :owner && membership.owner
-        user = membership.owner
-      else
-        user = create(:user)
-        membership.public_send(:"add_#{role}", user)
-      end
+      role = user_type_or_trait
+      user =
+        if role == :owner && membership.owner
+          membership.owner
+        else
+          create(:user).tap do |new_user|
+            membership.public_send(:"add_#{role}", new_user)
+          end
+        end
 
       login_as(user)
     else

spec/support/matchers/markdown_matchers.rb

@@ -159,15 +159,6 @@ module MarkdownMatchers
     end
   end
 
-  # EpicReferenceFilter
-  matcher :reference_epics do
-    set_default_markdown_messages
-
-    match do |actual|
-      expect(actual).to have_selector('a.gfm.gfm-epic', count: 5)
-    end
-  end
-
   # TaskListFilter
   matcher :parse_task_lists do
     set_default_markdown_messages
@@ -237,3 +228,5 @@ module RSpec::Matchers::DSL::Macros
     end
   end
 end
+
+MarkdownMatchers.prepend(EE::MarkdownMatchers)

spec/support/prometheus/additional_metrics_shared_examples.rb

@@ -116,50 +116,6 @@ RSpec.shared_examples 'additional metrics query' do
     end
   end
 
-  context 'with custom metrics' do
-    let!(:metric) { create(:prometheus_metric, project: project) }
-    before do
-      allow(client).to receive(:query_range).with('avg(metric)', any_args).and_return(query_range_result)
-    end
-
-    context 'without common metrics' do
-      before do
-        allow(metric_group_class).to receive(:common_metrics).and_return([])
-      end
-
-      it 'return group data for custom metric' do
-        queries_with_result = { queries: [{ query_range: 'avg(metric)', unit: 'm/s', label: 'legend', result: query_range_result }] }
-        expect(query_result).to match_schema('prometheus/additional_metrics_query_result')
-
-        expect(query_result.count).to eq(1)
-        expect(query_result.first[:metrics].count).to eq(1)
-
-        expect(query_result.first[:metrics].first).to include(queries_with_result)
-      end
-    end
-
-    context 'with common metrics' do
-      before do
-        allow(client).to receive(:query_range).with('query_range_a', any_args).and_return(query_range_result)
-
-        allow(metric_group_class).to receive(:common_metrics).and_return([simple_metric_group(metrics: [simple_metric])])
-      end
-
-      it 'return group data for custom metric' do
-        custom_queries_with_result = { queries: [{ query_range: 'avg(metric)', unit: 'm/s', label: 'legend', result: query_range_result }] }
-        common_queries_with_result = { queries: [{ query_range: 'query_range_a', result: query_range_result }] }
-
-        expect(query_result).to match_schema('prometheus/additional_metrics_query_result')
-
-        expect(query_result.count).to eq(2)
-        expect(query_result).to all(satisfy { |r| r[:metrics].count == 1 })
-
-        expect(query_result[0][:metrics].first).to include(common_queries_with_result)
-        expect(query_result[1][:metrics].first).to include(custom_queries_with_result)
-      end
-    end
-  end
-
   context 'with two groups with one metric each' do
     let(:metrics) { [simple_metric(queries: [simple_query])] }
 

spec/support/shared_contexts/services_shared_context.rb

@@ -27,7 +27,7 @@ Service.available_services_names.each do |service|
     end
 
     before do
-      if service == 'github'
+      if service == 'github' && respond_to?(:stub_licensed_features)
         stub_licensed_features(github_project_service_integration: true)
         project.clear_memoization(:disabled_services)
         project.clear_memoization(:licensed_feature_available)

spec/support/shared_examples/mentionable_shared_examples.rb

@@ -5,13 +5,11 @@
 # - let(:set_mentionable_text) { lambda { |txt| "block that assigns txt to the subject's mentionable_text" } }
 
 shared_context 'mentionable context' do
-  let(:group)   { create(:group) }
   let(:project) { subject.project }
   let(:author)  { subject.author }
 
   let(:mentioned_issue) { create(:issue, project: project) }
   let!(:mentioned_mr) { create(:merge_request, source_project: project) }
-  let(:mentioned_epic) { create(:epic, group: group) }
   let(:mentioned_commit) { project.commit("HEAD~1") }
 
   let(:ext_proj)   { create(:project, :public, :repository) }
@@ -29,7 +27,6 @@ shared_context 'mentionable context' do
       These references are new:
         Issue:  #{mentioned_issue.to_reference}
         Merge:  #{mentioned_mr.to_reference}
-        Epic:  #{mentioned_epic.to_reference(project)}
         Commit: #{mentioned_commit.to_reference}
 
       This reference is a repeat and should only be mentioned once:
@@ -46,8 +43,6 @@ shared_context 'mentionable context' do
   end
 
   before do
-    stub_licensed_features(epics: true)
-
     # Wire the project's repository to return the mentioned commit, and +nil+
     # for any unrecognized commits.
     allow_any_instance_of(::Repository).to receive(:commit).and_call_original
@@ -72,10 +67,9 @@ shared_examples 'a mentionable' do
   it "extracts references from its reference property" do
     # De-duplicate and omit itself
     refs = subject.referenced_mentionables
-    expect(refs.size).to eq(7)
+    expect(refs.size).to eq(6)
     expect(refs).to include(mentioned_issue)
     expect(refs).to include(mentioned_mr)
-    expect(refs).to include(mentioned_epic)
     expect(refs).to include(mentioned_commit)
     expect(refs).to include(ext_issue)
     expect(refs).to include(ext_mr)
@@ -83,7 +77,7 @@ shared_examples 'a mentionable' do
   end
 
   it 'creates cross-reference notes' do
-    mentioned_objects = [mentioned_issue, mentioned_mr, mentioned_epic, mentioned_commit,
+    mentioned_objects = [mentioned_issue, mentioned_mr, mentioned_commit,
                          ext_issue, ext_mr, ext_commit]
 
     mentioned_objects.each do |referenced|
@@ -103,7 +97,6 @@ shared_examples 'an editable mentionable' do
   let(:new_issues) do
     [create(:issue, project: project), create(:issue, project: ext_proj)]
   end
-  let(:new_epic) { create(:epic, group: group) }
 
   it 'creates new cross-reference notes when the mentionable text is edited' do
     subject.save
@@ -114,8 +107,6 @@ shared_examples 'an editable mentionable' do
 
       Issue:  #{mentioned_issue.to_reference}
 
-      Issue:  #{mentioned_epic.to_reference(project)}
-
       Commit: #{mentioned_commit.to_reference}
 
       ---
@@ -126,26 +117,23 @@ shared_examples 'an editable mentionable' do
 
       ---
 
-      These three references are introduced in an edit:
+      These two references are introduced in an edit:
 
       Issue: #{new_issues[0].to_reference}
 
       Cross: #{new_issues[1].to_reference(project)}
-
-      Epic: #{new_epic.to_reference(project)}
     MSG
 
-    # These four objects were already referenced, and should not receive new
+    # These three objects were already referenced, and should not receive new
     # notes
-    [mentioned_issue, mentioned_commit, mentioned_epic, ext_issue].each do |oldref|
+    [mentioned_issue, mentioned_commit, ext_issue].each do |oldref|
       expect(SystemNoteService).not_to receive(:cross_reference)
         .with(oldref, any_args)
     end
 
-    # These two issues and an epic are new and should receive reference notes
+    # These two issues are new and should receive reference notes
     # In the case of MergeRequests remember that cannot mention commits included in the MergeRequest
-    new_mentionables = new_issues + [new_epic]
-    new_mentionables.each do |newref|
+    new_issues.each do |newref|
       expect(SystemNoteService).to receive(:cross_reference)
         .with(newref, subject.local_reference, author)
     end

spec/support/webmock.rb

 require 'webmock'
 require 'webmock/rspec'
 
-def webmock_setup_defaults
-  allowed = %w[elasticsearch registry.gitlab.com-gitlab-org-test-elastic-image]
-
-  if ENV.key?('ELASTIC_URL')
-    url = URI.parse(ENV['ELASTIC_URL'])
-    allowed << url.host
-    allowed.uniq!
-  end
-
-  WebMock.disable_net_connect!(allow_localhost: true, allow: allowed)
+def webmock_allowed_hosts
+  %w[elasticsearch registry.gitlab.com-gitlab-org-test-elastic-image].tap do |hosts|
+    if ENV.key?('ELASTIC_URL')
+      hosts << URI.parse(ENV['ELASTIC_URL']).host
+    end
+  end.uniq
 end
 
-webmock_setup_defaults
+WebMock.disable_net_connect!(allow_localhost: true, allow: webmock_allowed_hosts)