Create project forks using factories

Fork of a project takes more than a second in tests
If we specify a target project that has been created using a factory
We can reduce this time to ~0.4s

ee/spec/lib/gitlab/auth/group_saml/gma_membership_enforcer_spec.rb

@@ -31,12 +31,12 @@ RSpec.describe Gitlab::Auth::GroupSaml::GmaMembershipEnforcer do
   end
 
   context 'when the project is forked' do
-    subject { described_class.new(fork_project(project, managed_user_for_project)) }
-
     before do
       project.add_developer(managed_user_for_project)
     end
 
+    subject { described_class.new(fork_project(project, managed_user_for_project)) }
+
     context 'when user is group-managed' do
       it 'allows adding user to project' do
         expect(subject.can_add_user?(managed_user)).to be_truthy
@@ -48,27 +48,26 @@ RSpec.describe Gitlab::Auth::GroupSaml::GmaMembershipEnforcer do
         expect(subject.can_add_user?(create(:user))).to be_falsey
       end
     end
-  end
 
-  context 'when the project is forked from deleted project' do
-    let!(:forked_project) { fork_project(project, managed_user_for_project) }
+    context 'from deleted project' do
+      let!(:forked_project) { fork_project(project, managed_user_for_project) }
 
-    before do
-      project.add_developer(managed_user_for_project)
-      project.delete
-    end
+      before do
+        project.delete
+      end
 
-    context 'when user is group-managed' do
-      it 'allows adding user to project' do
-        subject = described_class.new(forked_project)
-        expect(subject.can_add_user?(managed_user)).to be_truthy
+      context 'when user is group-managed' do
+        it 'allows adding user to project' do
+          subject = described_class.new(forked_project)
+          expect(subject.can_add_user?(managed_user)).to be_truthy
+        end
       end
-    end
 
-    context 'when user is not group-managed' do
-      it 'does not allow adding user to project' do
-        subject = described_class.new(forked_project)
-        expect(subject.can_add_user?(create(:user))).to be_truthy
+      context 'when user is not group-managed' do
+        it 'does not allow adding user to project' do
+          subject = described_class.new(forked_project)
+          expect(subject.can_add_user?(create(:user))).to be_truthy
+        end
       end
     end
   end

spec/features/projects_spec.rb

@@ -159,7 +159,7 @@ RSpec.describe 'Project' do
 
   describe 'remove forked relationship', :js do
     let(:user)    { create(:user) }
-    let(:project) { fork_project(create(:project, :public), user, namespace_id: user.namespace) }
+    let(:project) { fork_project(create(:project, :public), user, namespace: user.namespace) }
 
     before do
       sign_in user

spec/services/git/branch_hooks_service_spec.rb

@@ -348,7 +348,7 @@ RSpec.describe Git::BranchHooksService do
 
     context 'when the project is forked', :sidekiq_might_not_need_inline do
       let(:upstream_project) { project }
-      let(:forked_project) { fork_project(upstream_project, user, repository: true) }
+      let(:forked_project) { fork_project(upstream_project, user, repository: true, using_service: true) }
 
       let!(:forked_service) do
         described_class.new(forked_project, user, change: { oldrev: oldrev, newrev: newrev, ref: ref })

spec/services/merge_requests/build_service_spec.rb

@@ -88,6 +88,10 @@ RSpec.describe MergeRequests::BuildService do
       let(:source_project) { fork_project(project, user) }
       let(:merge_request) { described_class.new(project, user, mr_params).execute }
 
+      before do
+        project.add_reporter(user)
+      end
+
       it 'assigns force_remove_source_branch' do
         expect(merge_request.force_remove_source_branch?).to be_truthy
       end

spec/services/projects/fork_service_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Projects::ForkService do
     it 'flushes the forks count cache of the source project', :clean_gitlab_redis_cache do
       expect(from_project.forks_count).to be_zero
 
-      fork_project(from_project, to_user)
+      fork_project(from_project, to_user, using_service: true)
       BatchLoader::Executor.clear_current
 
       expect(from_project.forks_count).to eq(1)
@@ -40,7 +40,7 @@ RSpec.describe Projects::ForkService do
             @guest = create(:user)
             @from_project.add_user(@guest, :guest)
           end
-          subject { fork_project(@from_project, @guest) }
+          subject { fork_project(@from_project, @guest, using_service: true) }
 
           it { is_expected.not_to be_persisted }
           it { expect(subject.errors[:forked_from_project_id]).to eq(['is forbidden']) }
@@ -56,7 +56,7 @@ RSpec.describe Projects::ForkService do
         end
 
         describe "successfully creates project in the user namespace" do
-          let(:to_project) { fork_project(@from_project, @to_user, namespace: @to_user.namespace) }
+          let(:to_project) { fork_project(@from_project, @to_user, namespace: @to_user.namespace, using_service: true) }
 
           it { expect(to_project).to be_persisted }
           it { expect(to_project.errors).to be_empty }
@@ -92,21 +92,21 @@ RSpec.describe Projects::ForkService do
           end
 
           it 'imports the repository of the forked project', :sidekiq_might_not_need_inline do
-            to_project = fork_project(@from_project, @to_user, repository: true)
+            to_project = fork_project(@from_project, @to_user, repository: true, using_service: true)
 
             expect(to_project.empty_repo?).to be_falsy
           end
         end
 
         context 'creating a fork of a fork' do
-          let(:from_forked_project) { fork_project(@from_project, @to_user) }
+          let(:from_forked_project) { fork_project(@from_project, @to_user, using_service: true) }
           let(:other_namespace) do
             group = create(:group)
             group.add_owner(@to_user)
             group
           end
 
-          let(:to_project) { fork_project(from_forked_project, @to_user, namespace: other_namespace) }
+          let(:to_project) { fork_project(from_forked_project, @to_user, namespace: other_namespace, using_service: true) }
 
           it 'sets the root of the network to the root project' do
             expect(to_project.fork_network.root_project).to eq(@from_project)
@@ -126,7 +126,7 @@ RSpec.describe Projects::ForkService do
       context 'project already exists' do
         it "fails due to validation, not transaction failure" do
           @existing_project = create(:project, :repository, creator_id: @to_user.id, name: @from_project.name, namespace: @to_namespace)
-          @to_project = fork_project(@from_project, @to_user, namespace: @to_namespace)
+          @to_project = fork_project(@from_project, @to_user, namespace: @to_namespace, using_service: true)
           expect(@existing_project).to be_persisted
 
           expect(@to_project).not_to be_persisted
@@ -137,7 +137,7 @@ RSpec.describe Projects::ForkService do
 
       context 'repository in legacy storage already exists' do
         let(:fake_repo_path) { File.join(TestEnv.repos_path, @to_user.namespace.full_path, "#{@from_project.path}.git") }
-        let(:params) { { namespace: @to_user.namespace } }
+        let(:params) { { namespace: @to_user.namespace, using_service: true } }
 
         before do
           stub_application_setting(hashed_storage_enabled: false)
@@ -169,13 +169,13 @@ RSpec.describe Projects::ForkService do
       context 'GitLab CI is enabled' do
         it "forks and enables CI for fork" do
           @from_project.enable_ci
-          @to_project = fork_project(@from_project, @to_user)
+          @to_project = fork_project(@from_project, @to_user, using_service: true)
           expect(@to_project.builds_enabled?).to be_truthy
         end
       end
 
       context "CI/CD settings" do
-        let(:to_project) { fork_project(@from_project, @to_user) }
+        let(:to_project) { fork_project(@from_project, @to_user, using_service: true) }
 
         context "when origin has git depth specified" do
           before do
@@ -206,7 +206,7 @@ RSpec.describe Projects::ForkService do
           end
 
           it "creates fork with lowest level" do
-            forked_project = fork_project(@from_project, @to_user)
+            forked_project = fork_project(@from_project, @to_user, using_service: true)
 
             expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
           end
@@ -218,7 +218,7 @@ RSpec.describe Projects::ForkService do
           end
 
           it "creates fork with private visibility levels" do
-            forked_project = fork_project(@from_project, @to_user)
+            forked_project = fork_project(@from_project, @to_user, using_service: true)
 
             expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
           end
@@ -232,7 +232,7 @@ RSpec.describe Projects::ForkService do
         end
 
         it 'fails' do
-          to_project = fork_project(@from_project, @to_user, namespace: @to_user.namespace)
+          to_project = fork_project(@from_project, @to_user, namespace: @to_user.namespace, using_service: true)
 
           expect(to_project.errors[:forked_from_project_id]).to eq(['is forbidden'])
         end
@@ -253,7 +253,7 @@ RSpec.describe Projects::ForkService do
         @group.add_user(@developer,   GroupMember::DEVELOPER)
         @project.add_user(@developer,   :developer)
         @project.add_user(@group_owner, :developer)
-        @opts = { namespace: @group }
+        @opts = { namespace: @group, using_service: true }
       end
 
       context 'fork project for group' do
@@ -299,7 +299,7 @@ RSpec.describe Projects::ForkService do
           group_owner = create(:user)
           private_group.add_owner(group_owner)
 
-          forked_project = fork_project(public_project, group_owner, namespace: private_group)
+          forked_project = fork_project(public_project, group_owner, namespace: private_group, using_service: true)
 
           expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
         end
@@ -310,7 +310,7 @@ RSpec.describe Projects::ForkService do
   context 'when a project is already forked' do
     it 'creates a new poolresository after the project is moved to a new shard' do
       project = create(:project, :public, :repository)
-      fork_before_move = fork_project(project)
+      fork_before_move = fork_project(project, nil, using_service: true)
 
       # Stub everything required to move a project to a Gitaly shard that does not exist
       allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('default').and_call_original
@@ -329,7 +329,7 @@ RSpec.describe Projects::ForkService do
         destination_storage_name: 'test_second_storage'
       )
       Projects::UpdateRepositoryStorageService.new(storage_move).execute
-      fork_after_move = fork_project(project.reload)
+      fork_after_move = fork_project(project.reload, nil, using_service: true)
       pool_repository_before_move = PoolRepository.joins(:shard)
                                       .find_by(source_project: project, shards: { name: 'default' })
       pool_repository_after_move = PoolRepository.joins(:shard)
@@ -350,7 +350,7 @@ RSpec.describe Projects::ForkService do
 
     context 'when no pool exists' do
       it 'creates a new object pool' do
-        forked_project = fork_project(fork_from_project, forker)
+        forked_project = fork_project(fork_from_project, forker, using_service: true)
 
         expect(forked_project.pool_repository).to eq(fork_from_project.pool_repository)
       end
@@ -360,7 +360,7 @@ RSpec.describe Projects::ForkService do
       let!(:pool_repository) { create(:pool_repository, source_project: fork_from_project) }
 
       it 'joins the object pool' do
-        forked_project = fork_project(fork_from_project, forker)
+        forked_project = fork_project(fork_from_project, forker, using_service: true)
 
         expect(forked_project.pool_repository).to eq(fork_from_project.pool_repository)
       end

spec/support/helpers/project_forks_helper.rb

@@ -17,14 +17,26 @@ module ProjectForksHelper
       project.add_developer(user)
     end
 
-    unless params[:namespace] || params[:namespace_id]
+    unless params[:namespace]
       params[:namespace] = create(:group)
       params[:namespace].add_owner(user)
     end
 
+    namespace = params[:namespace]
+    create_repository = params.delete(:repository)
+
+    unless params[:target_project] || params[:using_service]
+      target_level = [project.visibility_level, namespace.visibility_level].min
+      visibility_level = Gitlab::VisibilityLevel.closest_allowed_level(target_level)
+
+      params[:target_project] =
+        create(:project,
+          (:repository if create_repository),
+          visibility_level: visibility_level, creator: user, namespace: namespace)
+    end
+
     service = Projects::ForkService.new(project, user, params)
 
-    create_repository = params.delete(:repository)
     # Avoid creating a repository
     unless create_repository
       allow(RepositoryForkWorker).to receive(:perform_async).and_return(true)