Merge branch 'rc/move-more-ee-only-spec-files' into 'master'

Move EE-specific spec files that were not under spec/ee

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

ee/spec/controllers/groups/epics_controller_spec.rb

@@ -141,7 +141,7 @@ describe Groups::EpicsController do
           show_epic(:json)
 
           expect(response).to have_http_status(200)
-          expect(response).to match_response_schema('entities/epic')
+          expect(response).to match_response_schema('entities/epic', dir: 'ee')
         end
 
         context 'with unauthorized user' do

spec/factories/remote_mirrors.rb → ee/spec/factories/remote_mirrors.rb

-require_relative '../support/test_env'
-
 FactoryBot.define do
   factory :remote_mirror, class: 'RemoteMirror' do
     association :project, :repository

spec/ee/spec/lib/ee/gitlab/ci/config_spec.rb → ee/spec/lib/ee/gitlab/ci/config_spec.rb

@@ -6,7 +6,7 @@ describe EE::Gitlab::Ci::Config do
   let(:gitlab_ci_yml) do
     <<~HEREDOC
     include:
-      - /spec/ee/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml
+      - /ee/spec/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml
       - #{remote_location}
 
     image: ruby:2.2
@@ -38,7 +38,7 @@ describe EE::Gitlab::Ci::Config do
         POSTGRES_DB: $CI_ENVIRONMENT_SLUG
       HEREDOC
     end
-    let(:local_file_content) {  File.read("#{Rails.root}/spec/ee/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml") }
+    let(:local_file_content) {  File.read(Rails.root.join('ee/spec/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml')) }
 
     before do
       allow(project).to receive(:feature_available?).with(:external_files_in_gitlab_ci).and_return(true)

spec/ee/spec/lib/gitlab/ci/external/processor_spec.rb → ee/spec/lib/gitlab/ci/external/processor_spec.rb

@@ -107,7 +107,7 @@ describe Gitlab::Ci::External::Processor do
       let(:remote_file) { 'https://gitlab.com/gitlab-org/gitlab-ce/blob/1234/.gitlab-ci-1.yml' }
       let(:external_files) do
         [
-          '/spec/ee/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml',
+          '/ee/spec/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml',
           remote_file
         ]
       end
@@ -128,7 +128,7 @@ describe Gitlab::Ci::External::Processor do
       end
 
       before do
-        local_file_content = File.read("#{Rails.root}/spec/ee/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml")
+        local_file_content = File.read(Rails.root.join('ee/spec/fixtures/gitlab/ci/external_files/.gitlab-ci-template-1.yml'))
         allow_any_instance_of(Gitlab::Ci::External::File::Local).to receive(:fetch_local_content).and_return(local_file_content)
         WebMock.stub_request(:get, remote_file).to_return(body: remote_file_content)
       end

ee/spec/lib/ee/gitlab/email/handler/ee/service_desk_handler_spec.rb → ee/spec/lib/gitlab/email/handler/ee/service_desk_handler_spec.rb

@@ -8,7 +8,7 @@ describe Gitlab::Email::Handler::EE::ServiceDeskHandler do
     stub_config_setting(host: 'localhost')
   end
 
-  let(:email_raw) { fixture_file('emails/service_desk.eml') }
+  let(:email_raw) { fixture_file('emails/service_desk.eml', dir: 'ee') }
   let(:namespace) { create(:namespace, name: "email") }
 
   context 'service desk is enabled for the project' do
@@ -64,7 +64,7 @@ describe Gitlab::Email::Handler::EE::ServiceDeskHandler do
     end
 
     context 'when the email is forwarded through an alias' do
-      let(:email_raw) { fixture_file('emails/service_desk_forwarded.eml') }
+      let(:email_raw) { fixture_file('emails/service_desk_forwarded.eml', dir: 'ee') }
 
       it 'sends thank you the email and creates issue' do
         setup_attachment

ee/spec/lib/gitlab/email/handler_spec.rb

+require 'spec_helper'
+
+describe Gitlab::Email::Handler do
+  before do
+    stub_incoming_email_setting(enabled: true, address: "incoming+%{key}@appmail.adventuretime.ooo")
+    stub_config_setting(host: 'localhost')
+  end
+
+  describe '.for' do
+    def handler_for(fixture, mail_key)
+      described_class.for(fixture_file(fixture), mail_key)
+    end
+
+    def ee_handler_for(fixture, mail_key)
+      described_class.for(fixture_file(fixture, dir: 'ee'), mail_key)
+    end
+
+    context 'a Service Desk email' do
+      it 'uses the Service Desk handler when Service Desk is enabled' do
+        allow(License).to receive(:feature_available?).and_call_original
+        allow(License).to receive(:feature_available?).with(:service_desk).and_return(true)
+
+        expect(ee_handler_for('emails/service_desk.eml', 'some/project')).to be_instance_of(Gitlab::Email::Handler::EE::ServiceDeskHandler)
+      end
+
+      it 'uses no handler when Service Desk is disabled' do
+        allow(License).to receive(:feature_available?).and_call_original
+        allow(License).to receive(:feature_available?).with(:service_desk).and_return(false)
+
+        expect(ee_handler_for('emails/service_desk.eml', 'some/project')).to be_nil
+      end
+    end
+
+    context 'a new issue email' do
+      let!(:user) { create(:user, email: 'jake@adventuretime.ooo', incoming_email_token: 'auth_token') }
+
+      it 'uses the create issue handler when Service Desk is enabled' do
+        allow(License).to receive(:feature_available?).and_call_original
+        allow(License).to receive(:feature_available?).with(:service_desk).and_return(true)
+
+        expect(handler_for('emails/valid_new_issue.eml', 'some/project+auth_token')).to be_instance_of(Gitlab::Email::Handler::CreateIssueHandler)
+      end
+
+      it 'uses the create issue handler when Service Desk is disabled' do
+        allow(License).to receive(:feature_available?).and_call_original
+        allow(License).to receive(:feature_available?).with(:service_desk).and_return(false)
+
+        expect(handler_for('emails/valid_new_issue.eml', 'some/project+auth_token')).to be_instance_of(Gitlab::Email::Handler::CreateIssueHandler)
+      end
+    end
+  end
+end

ee/spec/lib/system_check/geo/authorized_keys_check_spec.rb

@@ -33,7 +33,7 @@ describe SystemCheck::Geo::AuthorizedKeysCheck do
 
       it 'skips when config file is not readable' do
         override_sshd_config('system_check/sshd_config')
-        allow(File).to receive(:readable?).with(expand_fixture_ee_path('system_check/sshd_config')) { false }
+        allow(File).to receive(:readable?).with(expand_fixture_path('system_check/sshd_config', dir: 'ee')) { false }
 
         expect_skipped('Cannot access OpenSSH configuration file')
 
@@ -167,6 +167,6 @@ describe SystemCheck::Geo::AuthorizedKeysCheck do
   end
 
   def override_sshd_config(relative_path)
-    allow(subject).to receive(:openssh_config_path) { expand_fixture_ee_path(relative_path) }
+    allow(subject).to receive(:openssh_config_path) { expand_fixture_path(relative_path, dir: 'ee') }
   end
 end

ee/spec/requests/api/v3/github_spec.rb

@@ -56,7 +56,7 @@ describe API::V3::Github do
         expect(json_response).to be_an(Array)
         expect(json_response.size).to eq(2)
 
-        expect(response).to match_response_schema('entities/github/repositories')
+        expect(response).to match_response_schema('entities/github/repositories', dir: 'ee')
       end
 
       it 'returns valid project path as name' do
@@ -104,7 +104,7 @@ describe API::V3::Github do
         expect(response).to include_pagination_headers
         expect(json_response).to be_an(Array)
 
-        expect(response).to match_response_schema('entities/github/branches')
+        expect(response).to match_response_schema('entities/github/branches', dir: 'ee')
       end
     end
 
@@ -142,7 +142,7 @@ describe API::V3::Github do
         get v3_api("/repos/#{project.namespace.path}/#{project.path}/commits/#{commit_id}", user)
 
         expect(response).to have_gitlab_http_status(200)
-        expect(response).to match_response_schema('entities/github/commit')
+        expect(response).to match_response_schema('entities/github/commit', dir: 'ee')
       end
     end
 

ee/spec/services/audit_event_service_spec.rb

@@ -116,4 +116,103 @@ describe AuditEventService do
       end
     end
   end
+
+  describe '#for_failed_login' do
+    let(:author_name) { 'testuser' }
+    let(:ip_address) { '127.0.0.1' }
+    let(:service) { described_class.new(author_name, nil, ip_address: ip_address) }
+    let(:event) { service.for_failed_login.unauth_security_event }
+
+    before do
+      stub_licensed_features(extended_audit_events: true)
+    end
+
+    it 'has the right type' do
+      expect(event.entity_type).to eq('User')
+    end
+
+    it 'has the right author' do
+      expect(event.details[:author_name]).to eq(author_name)
+    end
+
+    it 'has the right IP address' do
+      allow(service).to receive(:admin_audit_log_enabled?).and_return(true)
+
+      expect(event.details[:ip_address]).to eq(ip_address)
+    end
+
+    it 'has the right auth method for OAUTH' do
+      oauth_service = described_class.new(author_name, nil, ip_address: ip_address, with: 'ldap')
+      event = oauth_service.for_failed_login.unauth_security_event
+
+      expect(event.details[:failed_login]).to eq('LDAP')
+    end
+  end
+
+  describe 'license' do
+    let(:project) { create(:project) }
+    let(:user) { create(:user) }
+    let!(:service) { described_class.new(user, project, action: :create) }
+    let(:event) { service.for_project.security_event }
+
+    before do
+      disable_license_audit_features(service)
+    end
+
+    describe 'has the audit_admin feature' do
+      before do
+        allow(service).to receive(:admin_audit_log_enabled?).and_return(true)
+      end
+
+      it 'logs an audit event' do
+        expect { event }.to change(AuditEvent, :count).by(1)
+      end
+
+      it 'has the entity_path' do
+        expect(event.details[:entity_path]).to eq(project.full_path)
+      end
+    end
+
+    describe 'has the extended_audit_events feature' do
+      before do
+        allow(service).to receive(:entity_audit_events_enabled?).and_return(true)
+      end
+
+      it 'logs an audit event' do
+        expect { event }.to change(AuditEvent, :count).by(1)
+      end
+
+      it 'has not the entity_path' do
+        expect(event.details[:entity_path]).not_to eq(project.full_path)
+      end
+    end
+
+    describe 'entity has the audit_events feature' do
+      before do
+        allow(service).to receive(:audit_events_enabled?).and_return(true)
+      end
+
+      it 'logs an audit event' do
+        expect { event }.to change(AuditEvent, :count).by(1)
+      end
+
+      it 'has not the entity_path' do
+        expect(event.details[:entity_path]).not_to eq(project.full_path)
+      end
+    end
+
+    describe 'has not any audit event feature' do
+      it 'does not log the audit event' do
+        expect { event }.not_to change(AuditEvent, :count)
+      end
+    end
+
+    def disable_license_audit_features(service)
+      [:entity_audit_events_enabled?,
+       :admin_audit_log_enabled?,
+       :audit_events_enabled?].each do |f|
+        allow(service).to receive(f).and_return(false)
+      end
+    end
+  end
 end

ee/spec/services/ci/register_job_service_spec.rb

+require 'spec_helper'
+
+describe Ci::RegisterJobService do
+  let!(:project) { create :project, shared_runners_enabled: false }
+  let!(:pipeline) { create :ci_empty_pipeline, project: project }
+  let!(:pending_build) { create :ci_build, pipeline: pipeline }
+  let(:shared_runner) { create(:ci_runner, :shared) }
+
+  describe '#execute' do
+    context 'for project with shared runners when global minutes limit is set' do
+      before do
+        project.update(shared_runners_enabled: true)
+        stub_application_setting(shared_runners_minutes: 100)
+      end
+
+      context 'allow to pick builds' do
+        let(:build) { execute(shared_runner) }
+
+        it { expect(build).to be_kind_of(Ci::Build) }
+      end
+
+      context 'when over the global quota' do
+        before do
+          project.namespace.create_namespace_statistics(
+            shared_runners_seconds: 6001)
+        end
+
+        let(:build) { execute(shared_runner) }
+
+        it "does not return a build" do
+          expect(build).to be_nil
+        end
+
+        context 'when project is public' do
+          before do
+            project.update(visibility_level: Project::PUBLIC)
+          end
+
+          it "does return the build" do
+            expect(build).to be_kind_of(Ci::Build)
+          end
+        end
+
+        context 'when namespace limit is set to unlimited' do
+          before do
+            project.namespace.update(shared_runners_minutes_limit: 0)
+          end
+
+          it "does return the build" do
+            expect(build).to be_kind_of(Ci::Build)
+          end
+        end
+
+        context 'when namespace quota is bigger than a global one' do
+          before do
+            project.namespace.update(shared_runners_minutes_limit: 101)
+          end
+
+          it "does return the build" do
+            expect(build).to be_kind_of(Ci::Build)
+          end
+        end
+      end
+
+      context 'when group is subgroup' do
+        let!(:root_ancestor) { create(:group) }
+        let!(:group) { create(:group, parent: root_ancestor) }
+        let!(:project) { create :project, shared_runners_enabled: true, group: group }
+        let(:build) { execute(shared_runner) }
+
+        context 'when shared_runner_minutes_on_root_namespace is disabled' do
+          before do
+            stub_feature_flags(shared_runner_minutes_on_root_namespace: false)
+          end
+
+          it "does return a build" do
+            expect(build).not_to be_nil
+          end
+
+          context 'when we are over limit on subnamespace' do
+            before do
+              group.create_namespace_statistics(
+                shared_runners_seconds: 6001)
+            end
+
+            it "does not return a build" do
+              expect(build).to be_nil
+            end
+          end
+        end
+
+        context 'when shared_runner_minutes_on_root_namespace is enabled', :nested_groups do
+          before do
+            stub_feature_flags(shared_runner_minutes_on_root_namespace: true)
+          end
+
+          it "does return a build" do
+            expect(build).not_to be_nil
+          end
+
+          context 'when we are over limit on subnamespace' do
+            before do
+              group.create_namespace_statistics(
+                shared_runners_seconds: 6001)
+            end
+
+            it "limit is ignored and build is returned" do
+              expect(build).not_to be_nil
+            end
+          end
+
+          context 'when we are over limit on root namespace' do
+            before do
+              root_ancestor.create_namespace_statistics(
+                shared_runners_seconds: 6001)
+            end
+
+            it "does not return a build" do
+              expect(build).to be_nil
+            end
+          end
+        end
+      end
+    end
+
+    def execute(runner)
+      described_class.new(runner).execute.build
+    end
+  end
+end

ee/spec/services/ee/audit_event_service_spec.rb

-require 'spec_helper'
-
-describe AuditEventService do
-  describe '#for_failed_login' do
-    let(:author_name) { 'testuser' }
-    let(:ip_address) { '127.0.0.1' }
-    let(:service) { described_class.new(author_name, nil, ip_address: ip_address) }
-    let(:event) { service.for_failed_login.unauth_security_event }
-
-    before do
-      stub_licensed_features(extended_audit_events: true)
-    end
-
-    it 'has the right type' do
-      expect(event.entity_type).to eq('User')
-    end
-
-    it 'has the right author' do
-      expect(event.details[:author_name]).to eq(author_name)
-    end
-
-    it 'has the right IP address' do
-      allow(service).to receive(:admin_audit_log_enabled?).and_return(true)
-
-      expect(event.details[:ip_address]).to eq(ip_address)
-    end
-
-    it 'has the right auth method for OAUTH' do
-      oauth_service = described_class.new(author_name, nil, ip_address: ip_address, with: 'ldap')
-      event = oauth_service.for_failed_login.unauth_security_event
-
-      expect(event.details[:failed_login]).to eq('LDAP')
-    end
-  end
-
-  describe 'license' do
-    let(:project) { create(:project) }
-    let(:user) { create(:user) }
-    let!(:service) { described_class.new(user, project, action: :create) }
-    let(:event) { service.for_project.security_event }
-
-    before do
-      disable_license_audit_features(service)
-    end
-
-    describe 'has the audit_admin feature' do
-      before do
-        allow(service).to receive(:admin_audit_log_enabled?).and_return(true)
-      end
-
-      it 'logs an audit event' do
-        expect { event }.to change(AuditEvent, :count).by(1)
-      end
-
-      it 'has the entity_path' do
-        expect(event.details[:entity_path]).to eq(project.full_path)
-      end
-    end
-
-    describe 'has the extended_audit_events feature' do
-      before do
-        allow(service).to receive(:entity_audit_events_enabled?).and_return(true)
-      end
-
-      it 'logs an audit event' do
-        expect { event }.to change(AuditEvent, :count).by(1)
-      end
-
-      it 'has not the entity_path' do
-        expect(event.details[:entity_path]).not_to eq(project.full_path)
-      end
-    end
-
-    describe 'entity has the audit_events feature' do
-      before do
-        allow(service).to receive(:audit_events_enabled?).and_return(true)
-      end
-
-      it 'logs an audit event' do
-        expect { event }.to change(AuditEvent, :count).by(1)
-      end
-
-      it 'has not the entity_path' do
-        expect(event.details[:entity_path]).not_to eq(project.full_path)
-      end
-    end
-
-    describe 'has not any audit event feature' do
-      it 'does not log the audit event' do
-        expect { event }.not_to change(AuditEvent, :count)
-      end
-    end
-
-    def disable_license_audit_features(service)
-      [:entity_audit_events_enabled?,
-       :admin_audit_log_enabled?,
-       :audit_events_enabled?].each do |f|
-        allow(service).to receive(f).and_return(false)
-      end
-    end
-  end
-end

ee/spec/services/ee/ci/register_job_service_spec.rb

-require 'spec_helper'
-
-module Ci
-  describe RegisterJobService do
-    let!(:project) { create :project, shared_runners_enabled: false }
-    let!(:pipeline) { create :ci_empty_pipeline, project: project }
-    let!(:pending_build) { create :ci_build, pipeline: pipeline }
-    let(:shared_runner) { create(:ci_runner, :shared) }
-
-    describe '#execute' do
-      context 'for project with shared runners when global minutes limit is set' do
-        before do
-          project.update(shared_runners_enabled: true)
-          stub_application_setting(shared_runners_minutes: 100)
-        end
-
-        context 'allow to pick builds' do
-          let(:build) { execute(shared_runner) }
-
-          it { expect(build).to be_kind_of(Build) }
-        end
-
-        context 'when over the global quota' do
-          before do
-            project.namespace.create_namespace_statistics(
-              shared_runners_seconds: 6001)
-          end
-
-          let(:build) { execute(shared_runner) }
-
-          it "does not return a build" do
-            expect(build).to be_nil
-          end
-
-          context 'when project is public' do
-            before do
-              project.update(visibility_level: Project::PUBLIC)
-            end
-
-            it "does return the build" do
-              expect(build).to be_kind_of(Build)
-            end
-          end
-
-          context 'when namespace limit is set to unlimited' do
-            before do
-              project.namespace.update(shared_runners_minutes_limit: 0)
-            end
-
-            it "does return the build" do
-              expect(build).to be_kind_of(Build)
-            end
-          end
-
-          context 'when namespace quota is bigger than a global one' do
-            before do
-              project.namespace.update(shared_runners_minutes_limit: 101)
-            end
-
-            it "does return the build" do
-              expect(build).to be_kind_of(Build)
-            end
-          end
-        end
-
-        context 'when group is subgroup' do
-          let!(:root_ancestor) { create(:group) }
-          let!(:group) { create(:group, parent: root_ancestor) }
-          let!(:project) { create :project, shared_runners_enabled: true, group: group }
-          let(:build) { execute(shared_runner) }
-
-          context 'when shared_runner_minutes_on_root_namespace is disabled' do
-            before do
-              stub_feature_flags(shared_runner_minutes_on_root_namespace: false)
-            end
-
-            it "does return a build" do
-              expect(build).not_to be_nil
-            end
-
-            context 'when we are over limit on subnamespace' do
-              before do
-                group.create_namespace_statistics(
-                  shared_runners_seconds: 6001)
-              end
-
-              it "does not return a build" do
-                expect(build).to be_nil
-              end
-            end
-          end
-
-          context 'when shared_runner_minutes_on_root_namespace is enabled', :nested_groups do
-            before do
-              stub_feature_flags(shared_runner_minutes_on_root_namespace: true)
-            end
-
-            it "does return a build" do
-              expect(build).not_to be_nil
-            end
-
-            context 'when we are over limit on subnamespace' do
-              before do
-                group.create_namespace_statistics(
-                  shared_runners_seconds: 6001)
-              end
-
-              it "limit is ignored and build is returned" do
-                expect(build).not_to be_nil
-              end
-            end
-
-            context 'when we are over limit on root namespace' do
-              before do
-                root_ancestor.create_namespace_statistics(
-                  shared_runners_seconds: 6001)
-              end
-
-              it "does not return a build" do
-                expect(build).to be_nil
-              end
-            end
-          end
-        end
-      end
-
-      def execute(runner)
-        described_class.new(runner).execute.build
-      end
-    end
-  end
-end

ee/spec/support/factory_bot.rb

+RSpec.configure do |config|
+  config.before(:suite) do
+    FactoryBot.definition_file_paths = [
+      Rails.root.join('ee', 'spec', 'factories')
+    ]
+    FactoryBot.find_definitions
+  end
+end

features/support/env.rb

@@ -26,17 +26,24 @@ Dir["#{Rails.root}/features/steps/shared/*.rb"].each { |file| require file }
 Spinach.hooks.before_run do
   include RSpec::Mocks::ExampleMethods
   include ActiveJob::TestHelper
+  include FactoryBot::Syntax::Methods
+  include GitlabRoutingHelper
+
   RSpec::Mocks.setup
   TestEnv.init(mailer: false)
+
+  # EE-specific START
+  FactoryBot.definition_file_paths = [
+    Rails.root.join('ee', 'spec', 'factories')
+  ]
+  FactoryBot.find_definitions
   License.destroy_all
   TestLicense.init
+  # EE-specific END
 
   # skip pre-receive hook check so we can use
   # web editor and merge
   TestEnv.disable_pre_receive
-
-  include FactoryBot::Syntax::Methods
-  include GitlabRoutingHelper
 end
 
 Spinach.hooks.after_scenario do |scenario_data, step_definitions|

spec/lib/gitlab/email/handler_spec.rb

 require 'spec_helper'
 
 describe Gitlab::Email::Handler do
-  before do
-    stub_incoming_email_setting(enabled: true, address: "incoming+%{key}@appmail.adventuretime.ooo")
-    stub_config_setting(host: 'localhost')
-  end
-
   describe '.for' do
     it 'picks issue handler if there is not merge request prefix' do
       expect(described_class.for('email', 'project+key')).to be_an_instance_of(Gitlab::Email::Handler::CreateIssueHandler)
@@ -18,43 +13,5 @@ describe Gitlab::Email::Handler do
     it 'returns nil if no handler is found' do
       expect(described_class.for('email', '')).to be_nil
     end
-
-    def handler_for(fixture, mail_key)
-      described_class.for(fixture_file(fixture), mail_key)
-    end
-
-    context 'a Service Desk email' do
-      it 'uses the Service Desk handler when Service Desk is enabled' do
-        allow(License).to receive(:feature_available?).and_call_original
-        allow(License).to receive(:feature_available?).with(:service_desk).and_return(true)
-
-        expect(handler_for('emails/service_desk.eml', 'some/project')).to be_instance_of(Gitlab::Email::Handler::EE::ServiceDeskHandler)
-      end
-
-      it 'uses no handler when Service Desk is disabled' do
-        allow(License).to receive(:feature_available?).and_call_original
-        allow(License).to receive(:feature_available?).with(:service_desk).and_return(false)
-
-        expect(handler_for('emails/service_desk.eml', 'some/project')).to be_nil
-      end
-    end
-
-    context 'a new issue email' do
-      let!(:user) { create(:user, email: 'jake@adventuretime.ooo', incoming_email_token: 'auth_token') }
-
-      it 'uses the create issue handler when Service Desk is enabled' do
-        allow(License).to receive(:feature_available?).and_call_original
-        allow(License).to receive(:feature_available?).with(:service_desk).and_return(true)
-
-        expect(handler_for('emails/valid_new_issue.eml', 'some/project+auth_token')).to be_instance_of(Gitlab::Email::Handler::CreateIssueHandler)
-      end
-
-      it 'uses the create issue handler when Service Desk is disabled' do
-        allow(License).to receive(:feature_available?).and_call_original
-        allow(License).to receive(:feature_available?).with(:service_desk).and_return(false)
-
-        expect(handler_for('emails/valid_new_issue.eml', 'some/project+auth_token')).to be_instance_of(Gitlab::Email::Handler::CreateIssueHandler)
-      end
-    end
   end
 end

spec/mailers/previews/issues_csv_mailer_preview.rb

-class IssuesCsvMailerPreview < ActionMailer::Preview
-  def issues_csv_export
-    user = OpenStruct.new(notification_email: 'a@example.com')
-    project = Project.unscoped.first
-
-    Notify.issues_csv_email(user, project, "Dummy,Csv\n0,1", export_status)
-  end
-
-  private
-
-  def export_status
-    {
-      truncated: [true, false].sample,
-      rows_written: 632,
-      rows_expected: 891
-    }
-  end
-end

spec/support/fixture_helpers.rb

 module FixtureHelpers
-  def fixture_file(filename)
+  def fixture_file(filename, dir: '')
     return '' if filename.blank?
 
-    File.read(expand_fixture_path(filename))
+    File.read(expand_fixture_path(filename, dir: dir))
   end
 
-  def fixture_file_ee(filename)
-    return '' if filename.blank?
-
-    File.read(expand_fixture_ee_path(filename))
-  end
-
-  def expand_fixture_path(filename)
-    File.expand_path(Rails.root.join('spec/fixtures/', filename))
-  end
-
-  def expand_fixture_ee_path(filename)
-    File.expand_path(Rails.root.join('ee/spec/fixtures/', filename))
+  def expand_fixture_path(filename, dir: '')
+    File.expand_path(Rails.root.join(dir, 'spec', 'fixtures', filename))
   end
 end
 

spec/support/stub_configuration.rb

-require_dependency Rails.root.join('ee', 'spec', 'support', 'stub_configuration')
+require_dependency Rails.root.join('ee', 'spec', 'support', 'ee', 'stub_configuration')
 
 module StubConfiguration
   prepend EE::StubConfiguration