Add a project forks spec helper

The helper creates a fork of a project with all provided attributes,
but skipping the creation of the repository on disk.

features/steps/project/fork.rb

@@ -58,13 +58,13 @@ class Spinach::Features::ProjectFork < Spinach::FeatureSteps
 
   step 'I should see my fork on the list' do
     page.within('.js-projects-list-holder') do
-      project = @user.fork_of(@project)
+      project = @user.fork_of(@project.reload)
       expect(page).to have_content("#{project.namespace.human_name} / #{project.name}")
     end
   end
 
   step 'I make forked repo invalid' do
-    project = @user.fork_of(@project)
+    project = @user.fork_of(@project.reload)
     project.path = 'test-crappy-path'
     project.save!
   end

features/steps/project/forked_merge_requests.rb

@@ -5,6 +5,7 @@ class Spinach::Features::ProjectForkedMergeRequests < Spinach::FeatureSteps
   include SharedPaths
   include Select2Helper
   include WaitForRequests
+  include ProjectForksHelper
 
   step 'I am a member of project "Shop"' do
     @project = ::Project.find_by(name: "Shop")
@@ -13,7 +14,9 @@ class Spinach::Features::ProjectForkedMergeRequests < Spinach::FeatureSteps
   end
 
   step 'I have a project forked off of "Shop" called "Forked Shop"' do
-    @forked_project = Projects::ForkService.new(@project, @user).execute
+    @forked_project = fork_project(@project, @user,
+                                   namespace: @user.namespace,
+                                   repository: true)
   end
 
   step 'I click link "New Merge Request"' do

features/support/env.rb

@@ -10,7 +10,7 @@ if ENV['CI']
   Knapsack::Adapters::SpinachAdapter.bind
 end
 
-%w(select2_helper test_env repo_helpers wait_for_requests sidekiq).each do |f|
+%w(select2_helper test_env repo_helpers wait_for_requests sidekiq project_forks_helper).each do |f|
   require Rails.root.join('spec', 'support', f)
 end
 

spec/controllers/projects/blob_controller_spec.rb

 require 'rails_helper'
 
 describe Projects::BlobController do
+  include ProjectForksHelper
+
   let(:project) { create(:project, :public, :repository) }
 
   describe "GET show" do
@@ -226,9 +228,8 @@ describe Projects::BlobController do
     end
 
     context 'when user has forked project' do
-      let(:forked_project_link) { create(:forked_project_link, forked_from_project: project) }
-      let!(:forked_project) { forked_project_link.forked_to_project }
-      let(:guest) { forked_project.owner }
+      let!(:forked_project) { fork_project(project, guest, namespace: guest.namespace, repository: true) }
+      let(:guest) { create(:user) }
 
       before do
         sign_in(guest)

spec/controllers/projects/merge_requests/diffs_controller_spec.rb

 require 'spec_helper'
 
 describe Projects::MergeRequests::DiffsController do
+  include ProjectForksHelper
+
   let(:project) { create(:project, :repository) }
   let(:user)    { project.owner }
   let(:merge_request) { create(:merge_request_with_diffs, target_project: project, source_project: project) }
@@ -37,12 +39,12 @@ describe Projects::MergeRequests::DiffsController do
         render_views
 
         let(:project) { create(:project, :repository) }
-        let(:fork_project) { create(:forked_project_with_submodules) }
-        let(:merge_request) { create(:merge_request_with_diffs, source_project: fork_project, source_branch: 'add-submodule-version-bump', target_branch: 'master', target_project: project) }
+        let(:forked_project) { fork_project_with_submodules(project) }
+        let(:merge_request) { create(:merge_request_with_diffs, source_project: forked_project, source_branch: 'add-submodule-version-bump', target_branch: 'master', target_project: project) }
 
         before do
-          fork_project.build_forked_project_link(forked_to_project_id: fork_project.id, forked_from_project_id: project.id)
-          fork_project.save
+          project.add_developer(user)
+
           merge_request.reload
           go
         end

spec/controllers/projects/merge_requests_controller_spec.rb

 require 'spec_helper'
 
 describe Projects::MergeRequestsController do
+  include ProjectForksHelper
+
   let(:project) { create(:project, :repository) }
   let(:user)    { project.owner }
   let(:merge_request) { create(:merge_request_with_diffs, target_project: project, source_project: project) }
@@ -216,14 +218,11 @@ describe Projects::MergeRequestsController do
 
     context 'there is no source project' do
       let(:project)       { create(:project, :repository) }
-      let(:fork_project)  { create(:forked_project_with_submodules) }
-      let(:merge_request) { create(:merge_request, source_project: fork_project, source_branch: 'add-submodule-version-bump', target_branch: 'master', target_project: project) }
+      let(:forked_project)  { fork_project_with_submodules(project) }
+      let!(:merge_request) { create(:merge_request, source_project: forked_project, source_branch: 'add-submodule-version-bump', target_branch: 'master', target_project: project) }
 
       before do
-        fork_project.build_forked_project_link(forked_to_project_id: fork_project.id, forked_from_project_id: project.id)
-        fork_project.save
-        merge_request.reload
-        fork_project.destroy
+        forked_project.destroy
       end
 
       it 'closes MR without errors' do
@@ -612,21 +611,16 @@ describe Projects::MergeRequestsController do
 
   describe 'GET ci_environments_status' do
     context 'the environment is from a forked project' do
-      let!(:forked)       { create(:project, :repository) }
+      let!(:forked)       { fork_project(project, user, repository: true) }
       let!(:environment)  { create(:environment, project: forked) }
       let!(:deployment)   { create(:deployment, environment: environment, sha: forked.commit.id, ref: 'master') }
       let(:admin)         { create(:admin) }
 
       let(:merge_request) do
-        create(:forked_project_link, forked_to_project: forked,
-                                     forked_from_project: project)
-
         create(:merge_request, source_project: forked, target_project: project)
       end
 
       before do
-        forked.team << [user, :master]
-
         get :ci_environments_status,
           namespace_id: merge_request.project.namespace.to_param,
           project_id: merge_request.project,

spec/controllers/projects/notes_controller_spec.rb

 require 'spec_helper'
 
 describe Projects::NotesController do
+  include ProjectForksHelper
+
   let(:user)    { create(:user) }
   let(:project) { create(:project) }
   let(:issue)   { create(:issue, project: project) }
@@ -176,18 +178,16 @@ describe Projects::NotesController do
     context 'when creating a commit comment from an MR fork' do
       let(:project) { create(:project, :repository) }
 
-      let(:fork_project) do
-        create(:project, :repository).tap do |fork|
-          create(:forked_project_link, forked_to_project: fork, forked_from_project: project)
-        end
+      let(:forked_project) do
+        fork_project(project, nil, repository: true)
       end
 
       let(:merge_request) do
-        create(:merge_request, source_project: fork_project, target_project: project, source_branch: 'feature', target_branch: 'master')
+        create(:merge_request, source_project: forked_project, target_project: project, source_branch: 'feature', target_branch: 'master')
       end
 
       let(:existing_comment) do
-        create(:note_on_commit, note: 'a note', project: fork_project, commit_id: merge_request.commit_shas.first)
+        create(:note_on_commit, note: 'a note', project: forked_project, commit_id: merge_request.commit_shas.first)
       end
 
       def post_create(extra_params = {})
@@ -197,7 +197,7 @@ describe Projects::NotesController do
                project_id: project,
                target_type: 'merge_request',
                target_id: merge_request.id,
-               note_project_id: fork_project.id,
+               note_project_id: forked_project.id,
                in_reply_to_discussion_id: existing_comment.discussion_id
              }.merge(extra_params)
       end
@@ -219,16 +219,16 @@ describe Projects::NotesController do
       end
 
       context 'when the user has access to the fork' do
-        let(:discussion) { fork_project.notes.find_discussion(existing_comment.discussion_id) }
+        let(:discussion) { forked_project.notes.find_discussion(existing_comment.discussion_id) }
 
         before do
-          fork_project.add_developer(user)
+          forked_project.add_developer(user)
 
           existing_comment
         end
 
         it 'creates the note' do
-          expect { post_create }.to change { fork_project.notes.count }.by(1)
+          expect { post_create }.to change { forked_project.notes.count }.by(1)
         end
       end
     end

spec/controllers/projects_controller_spec.rb

 require('spec_helper')
 
 describe ProjectsController do
+  include ProjectForksHelper
+
   let(:project) { create(:project) }
   let(:public_project) { create(:project, :public) }
   let(:user) { create(:user) }
@@ -399,10 +401,10 @@ describe ProjectsController do
 
     context "when the project is forked" do
       let(:project)      { create(:project, :repository) }
-      let(:fork_project) { create(:project, :repository, forked_from_project: project) }
+      let(:forked_project) { fork_project(project, nil, repository: true) }
       let(:merge_request) do
         create(:merge_request,
-          source_project: fork_project,
+          source_project: forked_project,
           target_project: project)
       end
 
@@ -410,7 +412,7 @@ describe ProjectsController do
         project.merge_requests << merge_request
         sign_in(admin)
 
-        delete :destroy, namespace_id: fork_project.namespace, id: fork_project
+        delete :destroy, namespace_id: forked_project.namespace, id: forked_project
 
         expect(merge_request.reload.state).to eq('closed')
       end
@@ -477,18 +479,14 @@ describe ProjectsController do
       end
 
       context 'with forked project' do
-        let(:project_fork) { create(:project, :repository, namespace: user.namespace) }
-
-        before do
-          create(:forked_project_link, forked_to_project: project_fork)
-        end
+        let(:forked_project) { fork_project(create(:project, :public), user) }
 
         it 'removes fork from project' do
           delete(:remove_fork,
-              namespace_id: project_fork.namespace.to_param,
-              id: project_fork.to_param, format: :js)
+              namespace_id: forked_project.namespace.to_param,
+              id: forked_project.to_param, format: :js)
 
-          expect(project_fork.forked?).to be_falsey
+          expect(forked_project.reload.forked?).to be_falsey
           expect(flash[:notice]).to eq('The fork relationship has been removed.')
           expect(response).to render_template(:remove_fork)
         end

spec/features/dashboard/merge_requests_spec.rb

@@ -3,12 +3,13 @@ require 'spec_helper'
 feature 'Dashboard Merge Requests' do
   include FilterItemSelectHelper
   include SortingHelper
+  include ProjectForksHelper
 
   let(:current_user) { create :user }
   let(:project) { create(:project) }
 
   let(:public_project) { create(:project, :public, :repository) }
-  let(:forked_project) { Projects::ForkService.new(public_project, current_user).execute }
+  let(:forked_project) { fork_project(public_project, current_user, repository: true) }
 
   before do
     project.add_master(current_user)

spec/features/merge_requests/create_new_mr_from_fork_spec.rb

 require 'spec_helper'
 
 feature 'Creating a merge request from a fork', :js do
+  include ProjectForksHelper
+
   let(:user) { create(:user) }
   let(:project) { create(:project, :public, :repository) }
-  let!(:source_project) { ::Projects::ForkService.new(project, user).execute }
+  let!(:source_project) do
+    fork_project(project, user,
+                 repository: true,
+                 namespace: user.namespace)
+  end
 
   before do
     source_project.add_master(user)
@@ -49,7 +55,6 @@ feature 'Creating a merge request from a fork', :js do
       target_project_member = target_project.owner
       CreateBranchService.new(target_project, target_project_member)
         .execute('a-brand-new-branch-to-test', 'master')
-
       visit project_new_merge_request_path(source_project)
 
       first('.js-target-project').click
@@ -66,13 +71,18 @@ feature 'Creating a merge request from a fork', :js do
   end
 
   context 'creating to the source of a fork' do
-    let(:target_project) { project }
+    let!(:target_project) { project }
 
     it_behaves_like('create merge request to other project')
   end
 
   context 'creating to a sibling of a fork' do
-    let!(:target_project) { ::Projects::ForkService.new(project, create(:user)).execute }
+    let!(:target_project) do
+      other_user = create(:user)
+      fork_project(project, other_user,
+                   repository: true,
+                   namespace: other_user.namespace)
+    end
 
     it_behaves_like('create merge request to other project')
   end

spec/features/merge_requests/created_from_fork_spec.rb

 require 'spec_helper'
 
 feature 'Merge request created from fork' do
+  include ProjectForksHelper
+
   given(:user) { create(:user) }
   given(:project) { create(:project, :public, :repository) }
-  given(:fork_project) { create(:project, :public, :repository) }
+  given(:forked_project) { fork_project(project, user, repository: true) }
 
   given!(:merge_request) do
-    create(:forked_project_link, forked_to_project: fork_project,
-                                 forked_from_project: project)
-
-    create(:merge_request_with_diffs, source_project: fork_project,
+    create(:merge_request_with_diffs, source_project: forked_project,
                                       target_project: project,
                                       description: 'Test merge request')
   end
 
   background do
-    fork_project.team << [user, :master]
+    forked_project.team << [user, :master]
     sign_in user
   end
 
@@ -31,7 +30,7 @@ feature 'Merge request created from fork' do
 
     background do
       create(:note_on_commit, note: comment,
-                              project: fork_project,
+                              project: forked_project,
                               commit_id: merge_request.commit_shas.first)
     end
 
@@ -55,7 +54,7 @@ feature 'Merge request created from fork' do
   context 'source project is deleted' do
     background do
       MergeRequests::MergeService.new(project, user).execute(merge_request)
-      fork_project.destroy!
+      forked_project.destroy!
     end
 
     scenario 'user can access merge request', js: true do
@@ -69,7 +68,7 @@ feature 'Merge request created from fork' do
   context 'pipeline present in source project' do
     given(:pipeline) do
       create(:ci_pipeline,
-             project: fork_project,
+             project: forked_project,
              sha: merge_request.diff_head_sha,
              ref: merge_request.source_branch)
     end

spec/features/merge_requests/diffs_spec.rb

 require 'spec_helper'
 
 feature 'Diffs URL', js: true do
+  include ProjectForksHelper
+
   let(:project) { create(:project, :public, :repository) }
   let(:merge_request) { create(:merge_request, source_project: project) }
 
@@ -64,7 +66,7 @@ feature 'Diffs URL', js: true do
   context 'when editing file' do
     let(:author_user) { create(:user) }
     let(:user) { create(:user) }
-    let(:forked_project) { Projects::ForkService.new(project, author_user).execute }
+    let(:forked_project) { fork_project(project, author_user, repository: true) }
     let(:merge_request) { create(:merge_request_with_diffs, source_project: forked_project, target_project: project, author: author_user) }
     let(:changelog_id) { Digest::SHA1.hexdigest("CHANGELOG") }
 

spec/features/merge_requests/form_spec.rb

 require 'rails_helper'
 
 describe 'New/edit merge request', :js do
+  include ProjectForksHelper
+
   let!(:project)     { create(:project, :public, :repository) }
-  let(:fork_project) { create(:project, :repository, forked_from_project: project) }
+  let(:forked_project) { fork_project(project, nil, repository: true) }
   let!(:user)        { create(:user) }
   let!(:user2)       { create(:user) }
   let!(:milestone)   { create(:milestone, project: project) }
@@ -170,16 +172,16 @@ describe 'New/edit merge request', :js do
 
   context 'forked project' do
     before do
-      fork_project.team << [user, :master]
+      forked_project.team << [user, :master]
       sign_in(user)
     end
 
     context 'new merge request' do
       before do
         visit project_new_merge_request_path(
-          fork_project,
+          forked_project,
           merge_request: {
-            source_project_id: fork_project.id,
+            source_project_id: forked_project.id,
             target_project_id: project.id,
             source_branch: 'fix',
             target_branch: 'master'
@@ -238,7 +240,7 @@ describe 'New/edit merge request', :js do
     context 'edit merge request' do
       before do
         merge_request = create(:merge_request,
-                                 source_project: fork_project,
+                                 source_project: forked_project,
                                  target_project: project,
                                  source_branch: 'fix',
                                  target_branch: 'master'

spec/features/projects/issuable_templates_spec.rb

 require 'spec_helper'
 
 feature 'issuable templates', js: true do
+  include ProjectForksHelper
+
   let(:user) { create(:user) }
   let(:project) { create(:project, :public, :repository) }
   let(:issue_form_location) { '#content-body .issuable-details .detail-page-description' }
@@ -116,15 +118,13 @@ feature 'issuable templates', js: true do
   context 'user creates a merge request from a forked project using templates' do
     let(:template_content) { 'this is a test "feature-proposal" template' }
     let(:fork_user) { create(:user) }
-    let(:fork_project) { create(:project, :public, :repository) }
-    let(:merge_request) { create(:merge_request, :with_diffs, source_project: fork_project, target_project: project) }
+    let(:forked_project) { fork_project(project, fork_user) }
+    let(:merge_request) { create(:merge_request, :with_diffs, source_project: forked_project, target_project: project) }
 
     background do
       sign_out(:user)
 
       project.team << [fork_user, :developer]
-      fork_project.team << [fork_user, :master]
-      create(:forked_project_link, forked_to_project: fork_project, forked_from_project: project)
 
       sign_in(fork_user)
 

spec/features/projects/user_creates_directory_spec.rb

@@ -79,7 +79,7 @@ feature 'User creates a directory', js: true do
       fill_in(:commit_message, with: 'New commit message', visible: true)
       click_button('Create directory')
 
-      fork = user.fork_of(project2)
+      fork = user.fork_of(project2.reload)
 
       expect(current_path).to eq(project_new_merge_request_path(fork))
     end

spec/features/projects/user_creates_files_spec.rb

@@ -142,7 +142,7 @@ describe 'User creates files' do
         fill_in(:commit_message, with: 'New commit message', visible: true)
         click_button('Commit changes')
 
-        fork = user.fork_of(project2)
+        fork = user.fork_of(project2.reload)
 
         expect(current_path).to eq(project_new_merge_request_path(fork))
         expect(page).to have_content('New commit message')

spec/features/projects/user_deletes_files_spec.rb

@@ -59,7 +59,7 @@ describe 'User deletes files' do
       fill_in(:commit_message, with: 'New commit message', visible: true)
       click_button('Delete file')
 
-      fork = user.fork_of(project2)
+      fork = user.fork_of(project2.reload)
 
       expect(current_path).to eq(project_new_merge_request_path(fork))
       expect(page).to have_content('New commit message')

spec/features/projects/user_replaces_files_spec.rb

@@ -74,7 +74,7 @@ describe 'User replaces files' do
 
       expect(page).to have_content('Replacement file commit message')
 
-      fork = user.fork_of(project2)
+      fork = user.fork_of(project2.reload)
 
       expect(current_path).to eq(project_new_merge_request_path(fork))
 

spec/features/projects/user_uploads_files_spec.rb

@@ -39,6 +39,9 @@ describe 'User uploads files' do
       expect(current_path).to eq(project_new_merge_request_path(project))
 
       click_link('Changes')
+      find("a[data-action='diffs']", text: 'Changes').click
+
+      wait_for_requests
 
       expect(page).to have_content('Lorem ipsum dolor sit amet')
       expect(page).to have_content('Sed ut perspiciatis unde omnis')
@@ -51,7 +54,7 @@ describe 'User uploads files' do
       visit(project2_tree_path_root_ref)
     end
 
-    it 'uploads and commit a new fileto a forked project', js: true do
+    it 'uploads and commit a new file to a forked project', js: true do
       find('.add-to-tree').click
       click_link('Upload file')
 
@@ -69,11 +72,13 @@ describe 'User uploads files' do
 
       expect(page).to have_content('New commit message')
 
-      fork = user.fork_of(project2)
+      fork = user.fork_of(project2.reload)
 
       expect(current_path).to eq(project_new_merge_request_path(fork))
 
-      click_link('Changes')
+      find("a[data-action='diffs']", text: 'Changes').click
+
+      wait_for_requests
 
       expect(page).to have_content('Lorem ipsum dolor sit amet')
       expect(page).to have_content('Sed ut perspiciatis unde omnis')

spec/features/projects_spec.rb

 require 'spec_helper'
 
 feature 'Project' do
+  include ProjectForksHelper
+
   describe 'creating from template' do
     let(:user)    { create(:user) }
     let(:template) { Gitlab::ProjectTemplate.find(:rails) }
@@ -57,11 +59,10 @@ feature 'Project' do
 
   describe 'remove forked relationship', js: true do
     let(:user)    { create(:user) }
-    let(:project) { create(:project, namespace: user.namespace) }
+    let(:project) { fork_project(create(:project, :public), user, namespace_id: user.namespace) }
 
     before do
       sign_in user
-      create(:forked_project_link, forked_to_project: project)
       visit edit_project_path(project)
     end
 
@@ -71,7 +72,7 @@ feature 'Project' do
       remove_with_confirm('Remove fork relationship', project.path)
 
       expect(page).to have_content 'The fork relationship has been removed.'
-      expect(project.forked?).to be_falsey
+      expect(project.reload.forked?).to be_falsey
       expect(page).not_to have_content 'Remove fork relationship'
     end
   end

spec/finders/merge_requests_finder_spec.rb

 require 'spec_helper'
 
 describe MergeRequestsFinder do
+  include ProjectForksHelper
+
   let(:user)  { create :user }
   let(:user2) { create :user }
 
-  let(:project1) { create(:project) }
-  let(:project2) { create(:project, forked_from_project: project1) }
-  let(:project3) { create(:project, :archived, forked_from_project: project1) }
+  let(:project1) { create(:project, :public) }
+  let(:project2) { fork_project(project1, user) }
+  let(:project3) do
+    p = fork_project(project1, user)
+    p.update!(archived: true)
+    p
+  end
 
   let!(:merge_request1) { create(:merge_request, :simple, author: user, source_project: project2, target_project: project1) }
   let!(:merge_request2) { create(:merge_request, :simple, author: user, source_project: project2, target_project: project1, state: 'closed') }

spec/helpers/merge_requests_helper_spec.rb

 require 'spec_helper'
 
 describe MergeRequestsHelper do
+  include ProjectForksHelper
   describe 'ci_build_details_path' do
     let(:project) { create(:project) }
     let(:merge_request) { MergeRequest.new }
@@ -31,10 +32,10 @@ describe MergeRequestsHelper do
 
     describe 'within different projects' do
       let(:project) { create(:project) }
-      let(:fork_project) { create(:project, forked_from_project: project) }
-      let(:merge_request) { create(:merge_request, source_project: fork_project, target_project: project) }
+      let(:forked_project) { fork_project(project) }
+      let(:merge_request) { create(:merge_request, source_project: forked_project, target_project: project) }
       subject { format_mr_branch_names(merge_request) }
-      let(:source_title) { "#{fork_project.full_path}:#{merge_request.source_branch}" }
+      let(:source_title) { "#{forked_project.full_path}:#{merge_request.source_branch}" }
       let(:target_title) { "#{project.full_path}:#{merge_request.target_branch}" }
 
       it { is_expected.to eq([source_title, target_title]) }

spec/lib/gitlab/import_export/fork_spec.rb

 require 'spec_helper'
 
 describe 'forked project import' do
+  include ProjectForksHelper
+
   let(:user) { create(:user) }
   let!(:project_with_repo) { create(:project, :repository, name: 'test-repo-restorer', path: 'test-repo-restorer') }
   let!(:project) { create(:project, name: 'test-repo-restorer-no-repo', path: 'test-repo-restorer-no-repo') }
   let(:export_path) { "#{Dir.tmpdir}/project_tree_saver_spec" }
   let(:shared) { Gitlab::ImportExport::Shared.new(relative_path: project.full_path) }
   let(:forked_from_project) { create(:project, :repository) }
-  let(:fork_link) { create(:forked_project_link, forked_from_project: project_with_repo) }
+  let(:forked_project) { fork_project(project_with_repo, nil, repository: true) }
   let(:repo_saver) { Gitlab::ImportExport::RepoSaver.new(project: project_with_repo, shared: shared) }
   let(:bundle_path) { File.join(shared.export_path, Gitlab::ImportExport.project_bundle_filename) }
 
@@ -16,7 +18,7 @@ describe 'forked project import' do
   end
 
   let!(:merge_request) do
-    create(:merge_request, source_project: fork_link.forked_to_project, target_project: project_with_repo)
+    create(:merge_request, source_project: forked_project, target_project: project_with_repo)
   end
 
   let(:saver) do

spec/lib/gitlab/import_export/merge_request_parser_spec.rb

 require 'spec_helper'
 
 describe Gitlab::ImportExport::MergeRequestParser do
+  include ProjectForksHelper
+
   let(:user) { create(:user) }
   let!(:project) { create(:project, :repository, name: 'test-repo-restorer', path: 'test-repo-restorer') }
-  let(:forked_from_project) { create(:project, :repository) }
-  let(:fork_link) { create(:forked_project_link, forked_from_project: project) }
+  let(:forked_project) { fork_project(project) }
 
   let!(:merge_request) do
-    create(:merge_request, source_project: fork_link.forked_to_project, target_project: project)
+    create(:merge_request, source_project: forked_project, target_project: project)
   end
 
   let(:parsed_merge_request) do

spec/lib/gitlab/search_results_spec.rb

 require 'spec_helper'
 
 describe Gitlab::SearchResults do
+  include ProjectForksHelper
+
   let(:user) { create(:user) }
   let!(:project) { create(:project, name: 'foo') }
   let!(:issue) { create(:issue, project: project, title: 'foo') }
@@ -42,7 +44,7 @@ describe Gitlab::SearchResults do
     end
 
     it 'includes merge requests from source and target projects' do
-      forked_project = create(:project, forked_from_project: project)
+      forked_project = fork_project(project, user)
       merge_request_2 = create(:merge_request, target_project: project, source_project: forked_project, title: 'foo')
 
       results = described_class.new(user, Project.where(id: forked_project.id), 'foo')

spec/migrations/add_head_pipeline_for_each_merge_request_spec.rb

@@ -2,11 +2,12 @@ require 'spec_helper'
 require Rails.root.join('db', 'post_migrate', '20170508170547_add_head_pipeline_for_each_merge_request.rb')
 
 describe AddHeadPipelineForEachMergeRequest, :truncate do
+  include ProjectForksHelper
+
   let(:migration) { described_class.new }
 
   let!(:project) { create(:project) }
-  let!(:forked_project_link) { create(:forked_project_link, forked_from_project: project) }
-  let!(:other_project) { forked_project_link.forked_to_project }
+  let!(:other_project) { fork_project(project) }
 
   let!(:pipeline_1) { create(:ci_pipeline, project: project, ref: "branch_1") }
   let!(:pipeline_2) { create(:ci_pipeline, project: other_project, ref: "branch_1") }

spec/models/forked_project_link_spec.rb

 require 'spec_helper'
 
 describe ForkedProjectLink, "add link on fork" do
+  include ProjectForksHelper
+
   let(:project_from) { create(:project, :repository) }
   let(:project_to) { fork_project(project_from, user) }
   let(:user) { create(:user) }
-  let(:namespace) { user.namespace }
 
   def fork_project(from_project, user)
     shell = double('gitlab_shell', fork_repository: true)
@@ -73,13 +74,4 @@ describe ForkedProjectLink, "add link on fork" do
       expect(ForkedProjectLink.exists?(id: forked_project_link.id)).to eq(false)
     end
   end
-
-  def fork_project(from_project, user)
-    service = Projects::ForkService.new(from_project, user)
-    shell = double('gitlab_shell', fork_repository: true)
-
-    allow(service).to receive(:gitlab_shell).and_return(shell)
-
-    service.execute
-  end
 end

spec/models/merge_request_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe MergeRequest do
   include RepoHelpers
+  include ProjectForksHelper
 
   subject { create(:merge_request) }
 
@@ -52,8 +53,8 @@ describe MergeRequest do
 
     context 'for forks' do
       let(:project) { create(:project) }
-      let(:fork1) { create(:forked_project_link, forked_from_project: project).forked_to_project }
-      let(:fork2) { create(:forked_project_link, forked_from_project: project).forked_to_project }
+      let(:fork1) { fork_project(project) }
+      let(:fork2) { fork_project(project) }
 
       it 'allows merge requests for sibling-forks' do
         subject.source_project = fork1
@@ -894,7 +895,7 @@ describe MergeRequest do
 
   describe '#diverged_commits_count' do
     let(:project)      { create(:project, :repository) }
-    let(:fork_project) { create(:project, :repository, forked_from_project: project) }
+    let(:forked_project) { fork_project(project, nil, repository: true) }
 
     context 'when the target branch does not exist anymore' do
       subject { create(:merge_request, source_project: project, target_project: project) }
@@ -922,7 +923,7 @@ describe MergeRequest do
     end
 
     context 'diverged on fork' do
-      subject(:merge_request_fork_with_divergence) { create(:merge_request, :diverged, source_project: fork_project, target_project: project) }
+      subject(:merge_request_fork_with_divergence) { create(:merge_request, :diverged, source_project: forked_project, target_project: project) }
 
       it 'counts commits that are on target branch but not on source branch' do
         expect(subject.diverged_commits_count).to eq(29)
@@ -930,7 +931,7 @@ describe MergeRequest do
     end
 
     context 'rebased on fork' do
-      subject(:merge_request_rebased) { create(:merge_request, :rebased, source_project: fork_project, target_project: project) }
+      subject(:merge_request_rebased) { create(:merge_request, :rebased, source_project: forked_project, target_project: project) }
 
       it 'counts commits that are on target branch but not on source branch' do
         expect(subject.diverged_commits_count).to eq(0)
@@ -1456,11 +1457,7 @@ describe MergeRequest do
     end
 
     context 'with environments on source project' do
-      let(:source_project) do
-        create(:project, :repository) do |fork_project|
-          fork_project.create_forked_project_link(forked_to_project_id: fork_project.id, forked_from_project_id: project.id)
-        end
-      end
+      let(:source_project) { fork_project(project, nil, repository: true) }
 
       let(:merge_request) do
         create(:merge_request,
@@ -1822,14 +1819,14 @@ describe MergeRequest do
 
   describe "#source_project_missing?" do
     let(:project)      { create(:project) }
-    let(:fork_project) { create(:forked_project_link, forked_from_project: project).forked_to_project }
+    let(:forked_project) { fork_project(project) }
     let(:user)         { create(:user) }
-    let(:unlink_project) { Projects::UnlinkForkService.new(fork_project, user) }
+    let(:unlink_project) { Projects::UnlinkForkService.new(forked_project, user) }
 
     context "when the fork exists" do
       let(:merge_request) do
         create(:merge_request,
-          source_project: fork_project,
+          source_project: forked_project,
           target_project: project)
       end
 
@@ -1845,7 +1842,7 @@ describe MergeRequest do
     context "when the fork does not exist" do
       let!(:merge_request) do
         create(:merge_request,
-          source_project: fork_project,
+          source_project: forked_project,
           target_project: project)
       end
 
@@ -1868,14 +1865,14 @@ describe MergeRequest do
 
   describe "#closed_without_fork?" do
     let(:project)      { create(:project) }
-    let(:fork_project) { create(:project, forked_from_project: project) }
+    let(:forked_project) { fork_project(project) }
     let(:user)         { create(:user) }
-    let(:unlink_project) { Projects::UnlinkForkService.new(fork_project, user) }
+    let(:unlink_project) { Projects::UnlinkForkService.new(forked_project, user) }
 
     context "when the merge request is closed" do
       let(:closed_merge_request) do
         create(:closed_merge_request,
-          source_project: fork_project,
+          source_project: forked_project,
           target_project: project)
       end
 
@@ -1894,7 +1891,7 @@ describe MergeRequest do
     context "when the merge request is open" do
       let(:open_merge_request) do
         create(:merge_request,
-          source_project: fork_project,
+          source_project: forked_project,
           target_project: project)
       end
 
@@ -1913,24 +1910,24 @@ describe MergeRequest do
       end
 
       context 'forked project' do
-        let(:project)      { create(:project) }
+        let(:project)      { create(:project, :public) }
         let(:user)         { create(:user) }
-        let(:fork_project) { create(:project, forked_from_project: project, namespace: user.namespace) }
+        let(:forked_project) { fork_project(project, user) }
 
         let!(:merge_request) do
           create(:closed_merge_request,
-            source_project: fork_project,
+            source_project: forked_project,
             target_project: project)
         end
 
         it 'returns false if unforked' do
-          Projects::UnlinkForkService.new(fork_project, user).execute
+          Projects::UnlinkForkService.new(forked_project, user).execute
 
           expect(merge_request.reload.reopenable?).to be_falsey
         end
 
         it 'returns false if the source project is deleted' do
-          Projects::DestroyService.new(fork_project, user).execute
+          Projects::DestroyService.new(forked_project, user).execute
 
           expect(merge_request.reload.reopenable?).to be_falsey
         end

spec/models/project_spec.rb

@@ -2255,40 +2255,34 @@ describe Project do
   end
 
   context 'forks' do
+    include ProjectForksHelper
+
     let(:project) { create(:project, :public) }
     let!(:forked_project) { fork_project(project) }
 
-    def fork_project(project)
-      Projects::ForkService.new(project, create(:user)).execute
-    end
-
     describe '#fork_network' do
       it 'includes a fork of the project' do
-        expect(project.fork_network).to include(forked_project)
+        expect(project.fork_network.projects).to include(forked_project)
       end
 
       it 'includes a fork of a fork' do
         other_fork = fork_project(forked_project)
 
-        expect(project.fork_network).to include(other_fork)
+        expect(project.fork_network.projects).to include(other_fork)
       end
 
       it 'includes sibling forks' do
         other_fork = fork_project(project)
 
-        expect(forked_project.fork_network).to include(other_fork)
+        expect(forked_project.fork_network.projects).to include(other_fork)
       end
 
       it 'includes the base project' do
-        expect(forked_project.fork_network).to include(project)
+        expect(forked_project.fork_network.projects).to include(project.reload)
       end
     end
 
     describe '#in_fork_network_of?' do
-      it 'is false when the project is not a fork' do
-        expect(project.in_fork_network_of?(double)).to be_falsy
-      end
-
       it 'is true for a real fork' do
         expect(forked_project.in_fork_network_of?(project)).to be_truthy
       end

spec/models/user_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe User do
   include Gitlab::CurrentSettings
+  include ProjectForksHelper
 
   describe 'modules' do
     subject { described_class }
@@ -1376,7 +1377,7 @@ describe User do
   describe "#contributed_projects" do
     subject { create(:user) }
     let!(:project1) { create(:project) }
-    let!(:project2) { create(:project, forked_from_project: project3) }
+    let!(:project2) { fork_project(project3) }
     let!(:project3) { create(:project) }
     let!(:merge_request) { create(:merge_request, source_project: project2, target_project: project3, author: subject) }
     let!(:push_event) { create(:push_event, project: project1, author: subject) }

spec/requests/api/merge_requests_spec.rb

 require "spec_helper"
 
 describe API::MergeRequests do
+  include ProjectForksHelper
+
   let(:base_time)   { Time.now }
   let(:user)        { create(:user) }
   let(:admin)       { create(:user, :admin) }
@@ -619,17 +621,17 @@ describe API::MergeRequests do
 
     context 'forked projects' do
       let!(:user2) { create(:user) }
-      let!(:fork_project) { create(:project, forked_from_project: project,  namespace: user2.namespace, creator_id: user2.id) }
+      let!(:forked_project) { fork_project(project, user2) }
       let!(:unrelated_project) { create(:project,  namespace: create(:user).namespace, creator_id: user2.id) }
 
       before do
-        fork_project.add_reporter(user2)
+        forked_project.add_reporter(user2)
 
         allow_any_instance_of(MergeRequest).to receive(:write_ref)
       end
 
       it "returns merge_request" do
-        post api("/projects/#{fork_project.id}/merge_requests", user2),
+        post api("/projects/#{forked_project.id}/merge_requests", user2),
           title: 'Test merge_request', source_branch: "feature_conflict", target_branch: "master",
           author: user2, target_project_id: project.id, description: 'Test description for Test merge_request'
         expect(response).to have_gitlab_http_status(201)
@@ -638,10 +640,10 @@ describe API::MergeRequests do
       end
 
       it "does not return 422 when source_branch equals target_branch" do
-        expect(project.id).not_to eq(fork_project.id)
-        expect(fork_project.forked?).to be_truthy
-        expect(fork_project.forked_from_project).to eq(project)
-        post api("/projects/#{fork_project.id}/merge_requests", user2),
+        expect(project.id).not_to eq(forked_project.id)
+        expect(forked_project.forked?).to be_truthy
+        expect(forked_project.forked_from_project).to eq(project)
+        post api("/projects/#{forked_project.id}/merge_requests", user2),
         title: 'Test merge_request', source_branch: "master", target_branch: "master", author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(201)
         expect(json_response['title']).to eq('Test merge_request')
@@ -650,7 +652,7 @@ describe API::MergeRequests do
       it 'returns 422 when target project has disabled merge requests' do
         project.project_feature.update(merge_requests_access_level: 0)
 
-        post api("/projects/#{fork_project.id}/merge_requests", user2),
+        post api("/projects/#{forked_project.id}/merge_requests", user2),
              title: 'Test',
              target_branch: 'master',
              source_branch: 'markdown',
@@ -661,26 +663,26 @@ describe API::MergeRequests do
       end
 
       it "returns 400 when source_branch is missing" do
-        post api("/projects/#{fork_project.id}/merge_requests", user2),
+        post api("/projects/#{forked_project.id}/merge_requests", user2),
         title: 'Test merge_request', target_branch: "master", author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(400)
       end
 
       it "returns 400 when target_branch is missing" do
-        post api("/projects/#{fork_project.id}/merge_requests", user2),
+        post api("/projects/#{forked_project.id}/merge_requests", user2),
         title: 'Test merge_request', target_branch: "master", author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(400)
       end
 
       it "returns 400 when title is missing" do
-        post api("/projects/#{fork_project.id}/merge_requests", user2),
+        post api("/projects/#{forked_project.id}/merge_requests", user2),
         target_branch: 'master', source_branch: 'markdown', author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(400)
       end
 
       context 'when target_branch is specified' do
         it 'returns 422 if targeting a different fork' do
-          post api("/projects/#{fork_project.id}/merge_requests", user2),
+          post api("/projects/#{forked_project.id}/merge_requests", user2),
                title: 'Test merge_request',
                target_branch: 'master',
                source_branch: 'markdown',
@@ -691,8 +693,8 @@ describe API::MergeRequests do
       end
 
       it "returns 201 when target_branch is specified and for the same project" do
-        post api("/projects/#{fork_project.id}/merge_requests", user2),
-        title: 'Test merge_request', target_branch: 'master', source_branch: 'markdown', author: user2, target_project_id: fork_project.id
+        post api("/projects/#{forked_project.id}/merge_requests", user2),
+        title: 'Test merge_request', target_branch: 'master', source_branch: 'markdown', author: user2, target_project_id: forked_project.id
         expect(response).to have_gitlab_http_status(201)
       end
     end

spec/requests/api/projects_spec.rb

@@ -64,9 +64,12 @@ describe API::Projects do
           create(:project, :public)
         end
 
+        # TODO: We're currently querying to detect if a project is a fork
+        # in 2 ways. Lower this back to 8 when `ForkedProjectLink` relation is
+        # removed
         expect do
           get api('/projects', current_user)
-        end.not_to exceed_query_limit(control).with_threshold(8)
+        end.not_to exceed_query_limit(control).with_threshold(9)
       end
     end
 

spec/requests/api/v3/merge_requests_spec.rb

 require "spec_helper"
 
 describe API::MergeRequests do
+  include ProjectForksHelper
+
   let(:base_time)   { Time.now }
   let(:user)        { create(:user) }
   let(:admin)       { create(:user, :admin) }
@@ -315,17 +317,17 @@ describe API::MergeRequests do
 
     context 'forked projects' do
       let!(:user2) { create(:user) }
-      let!(:fork_project) { create(:project, forked_from_project: project,  namespace: user2.namespace, creator_id: user2.id) }
+      let!(:forked_project) { fork_project(project, user2) }
       let!(:unrelated_project) { create(:project,  namespace: create(:user).namespace, creator_id: user2.id) }
 
       before do
-        fork_project.add_reporter(user2)
+        forked_project.add_reporter(user2)
 
         allow_any_instance_of(MergeRequest).to receive(:write_ref)
       end
 
       it "returns merge_request" do
-        post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
+        post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
           title: 'Test merge_request', source_branch: "feature_conflict", target_branch: "master",
           author: user2, target_project_id: project.id, description: 'Test description for Test merge_request'
         expect(response).to have_gitlab_http_status(201)
@@ -334,10 +336,10 @@ describe API::MergeRequests do
       end
 
       it "does not return 422 when source_branch equals target_branch" do
-        expect(project.id).not_to eq(fork_project.id)
-        expect(fork_project.forked?).to be_truthy
-        expect(fork_project.forked_from_project).to eq(project)
-        post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
+        expect(project.id).not_to eq(forked_project.id)
+        expect(forked_project.forked?).to be_truthy
+        expect(forked_project.forked_from_project).to eq(project)
+        post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
         title: 'Test merge_request', source_branch: "master", target_branch: "master", author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(201)
         expect(json_response['title']).to eq('Test merge_request')
@@ -346,7 +348,7 @@ describe API::MergeRequests do
       it "returns 422 when target project has disabled merge requests" do
         project.project_feature.update(merge_requests_access_level: 0)
 
-        post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
+        post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
              title: 'Test',
              target_branch: "master",
              source_branch: 'markdown',
@@ -357,26 +359,26 @@ describe API::MergeRequests do
       end
 
       it "returns 400 when source_branch is missing" do
-        post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
+        post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
         title: 'Test merge_request', target_branch: "master", author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(400)
       end
 
       it "returns 400 when target_branch is missing" do
-        post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
+        post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
         title: 'Test merge_request', target_branch: "master", author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(400)
       end
 
       it "returns 400 when title is missing" do
-        post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
+        post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
         target_branch: 'master', source_branch: 'markdown', author: user2, target_project_id: project.id
         expect(response).to have_gitlab_http_status(400)
       end
 
       context 'when target_branch is specified' do
         it 'returns 422 if targeting a different fork' do
-          post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
+          post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
                title: 'Test merge_request',
                target_branch: 'master',
                source_branch: 'markdown',
@@ -387,8 +389,8 @@ describe API::MergeRequests do
       end
 
       it "returns 201 when target_branch is specified and for the same project" do
-        post v3_api("/projects/#{fork_project.id}/merge_requests", user2),
-        title: 'Test merge_request', target_branch: 'master', source_branch: 'markdown', author: user2, target_project_id: fork_project.id
+        post v3_api("/projects/#{forked_project.id}/merge_requests", user2),
+        title: 'Test merge_request', target_branch: 'master', source_branch: 'markdown', author: user2, target_project_id: forked_project.id
         expect(response).to have_gitlab_http_status(201)
       end
     end

spec/requests/lfs_http_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe 'Git LFS API and storage' do
   include WorkhorseHelpers
+  include ProjectForksHelper
 
   let(:user) { create(:user) }
   let!(:lfs_object) { create(:lfs_object, :with_file) }
@@ -1303,11 +1304,6 @@ describe 'Git LFS API and storage' do
     ActionController::HttpAuthentication::Basic.encode_credentials(user.username, Gitlab::LfsToken.new(user).token)
   end
 
-  def fork_project(project, user, object = nil)
-    allow(RepositoryForkWorker).to receive(:perform_async).and_return(true)
-    Projects::ForkService.new(project, user, {}).execute
-  end
-
   def post_lfs_json(url, body = nil, headers = nil)
     post(url, body.try(:to_json), (headers || {}).merge('Content-Type' => 'application/vnd.git-lfs+json'))
   end

spec/serializers/build_details_entity_spec.rb

 require 'spec_helper'
 
 describe BuildDetailsEntity do
+  include ProjectForksHelper
+
   set(:user) { create(:admin) }
 
   it 'inherits from JobEntity' do
@@ -56,18 +58,16 @@ describe BuildDetailsEntity do
       end
 
       context 'when merge request is from a fork' do
-        let(:fork_project) do
-          create(:project, forked_from_project: project)
-        end
+        let(:forked_project) { fork_project(project) }
 
-        let(:pipeline) { create(:ci_pipeline, project: fork_project) }
+        let(:pipeline) { create(:ci_pipeline, project: forked_project) }
 
         before do
           allow(build).to receive(:merge_request).and_return(merge_request)
         end
 
         let(:merge_request) do
-          create(:merge_request, source_project: fork_project,
+          create(:merge_request, source_project: forked_project,
                                  target_project: project,
                                  source_branch: build.ref)
         end

spec/services/ci/create_pipeline_service_spec.rb

 require 'spec_helper'
 
 describe Ci::CreatePipelineService do
+  include ProjectForksHelper
+
   set(:project) { create(:project, :repository) }
   let(:user) { create(:admin) }
   let(:ref_name) { 'refs/heads/master' }
@@ -82,13 +84,9 @@ describe Ci::CreatePipelineService do
         end
 
         context 'when merge request target project is different from source project' do
+          let!(:project) { fork_project(target_project, nil, repository: true) }
           let!(:target_project) { create(:project, :repository) }
 
-          let!(:forked_project_link) do
-            create(:forked_project_link, forked_to_project: project,
-                                         forked_from_project: target_project)
-          end
-
           it 'updates head pipeline for merge request' do
             merge_request = create(:merge_request, source_branch: 'master',
                                                    target_branch: "branch_1",

spec/services/delete_merged_branches_service_spec.rb

 require 'spec_helper'
 
 describe DeleteMergedBranchesService do
+  include ProjectForksHelper
+
   subject(:service) { described_class.new(project, project.owner) }
 
   let(:project) { create(:project, :repository) }
@@ -50,9 +52,9 @@ describe DeleteMergedBranchesService do
 
     context 'open merge requests' do
       it 'does not delete branches from open merge requests' do
-        fork_link = create(:forked_project_link, forked_from_project: project)
+        forked_project = fork_project(project)
         create(:merge_request, :opened, source_project: project, target_project: project, source_branch: 'branch-merged', target_branch: 'master')
-        create(:merge_request, :opened, source_project: fork_link.forked_to_project, target_project: project, target_branch: 'improve/awesome', source_branch: 'master')
+        create(:merge_request, :opened, source_project: forked_project, target_project: project, target_branch: 'improve/awesome', source_branch: 'master')
 
         service.execute
 

spec/services/merge_requests/conflicts/resolve_service_spec.rb

 require 'spec_helper'
 
 describe MergeRequests::Conflicts::ResolveService do
+  include ProjectForksHelper
   let(:user) { create(:user) }
-  let(:project) { create(:project, :repository) }
+  let(:project) { create(:project, :public, :repository) }
 
-  let(:fork_project) do
-    create(:forked_project_with_submodules) do |fork_project|
-      fork_project.build_forked_project_link(forked_to_project_id: fork_project.id, forked_from_project_id: project.id)
-      fork_project.save
-    end
+  let(:forked_project) do
+    fork_project_with_submodules(project, user)
   end
 
   let(:merge_request) do
@@ -19,7 +17,7 @@ describe MergeRequests::Conflicts::ResolveService do
 
   let(:merge_request_from_fork) do
     create(:merge_request,
-           source_branch: 'conflict-resolvable-fork', source_project: fork_project,
+           source_branch: 'conflict-resolvable-fork', source_project: forked_project,
            target_branch: 'conflict-start', target_project: project)
   end
 
@@ -114,7 +112,7 @@ describe MergeRequests::Conflicts::ResolveService do
         end
 
         it 'gets conflicts from the source project' do
-          expect(fork_project.repository.rugged).to receive(:merge_commits).and_call_original
+          expect(forked_project.repository.rugged).to receive(:merge_commits).and_call_original
           expect(project.repository.rugged).not_to receive(:merge_commits)
 
           resolve_conflicts

spec/services/merge_requests/get_urls_service_spec.rb

 require "spec_helper"
 
 describe MergeRequests::GetUrlsService do
+  include ProjectForksHelper
+
   let(:project) { create(:project, :public, :repository) }
   let(:service) { described_class.new(project) }
   let(:source_branch) { "merge-test" }
@@ -85,7 +87,7 @@ describe MergeRequests::GetUrlsService do
 
     context 'pushing to existing branch from forked project' do
       let(:user) { create(:user) }
-      let!(:forked_project) { Projects::ForkService.new(project, user).execute }
+      let!(:forked_project) { fork_project(project, user, repository: true) }
       let!(:merge_request) { create(:merge_request, source_project: forked_project, target_project: project, source_branch: source_branch) }
       let(:changes) { existing_branch_changes }
       # Source project is now the forked one

spec/services/merge_requests/refresh_service_spec.rb

 require 'spec_helper'
 
 describe MergeRequests::RefreshService do
+  include ProjectForksHelper
+
   let(:project) { create(:project, :repository) }
   let(:user) { create(:user) }
   let(:service) { described_class }
@@ -12,11 +14,7 @@ describe MergeRequests::RefreshService do
       group.add_owner(@user)
 
       @project = create(:project, :repository, namespace: group, approvals_before_merge: 1, reset_approvals_on_push: true)
-      @fork_project = Projects::ForkService.new(@project, @user).execute
-      # The call to project.repository.after_import in RepositoryForkWorker does
-      # not reset the @exists variable of @fork_project.repository so we have to
-      # explicitely call this method to clear the @exists variable.
-      @fork_project.repository.after_import
+      @fork_project = fork_project(@project, @user, repository: true)
 
       @merge_request = create(:merge_request,
                               source_project: @project,
@@ -410,8 +408,7 @@ describe MergeRequests::RefreshService do
 
       context 'when the merge request is sourced from a different project' do
         it 'creates a `MergeRequestsClosingIssues` record for each issue closed by a commit' do
-          forked_project = create(:project, :repository)
-          create(:forked_project_link, forked_to_project: forked_project, forked_from_project: @project)
+          forked_project = fork_project(@project, @user, repository: true)
 
           merge_request = create(:merge_request,
                                  target_branch: 'master',

spec/services/projects/fork_service_spec.rb

 require 'spec_helper'
 
 describe Projects::ForkService do
+  include ProjectForksHelper
   let(:gitlab_shell) { Gitlab::Shell.new }
 
   describe 'fork by user' do
@@ -33,7 +34,7 @@ describe Projects::ForkService do
       end
 
       describe "successfully creates project in the user namespace" do
-        let(:to_project) { fork_project(@from_project, @to_user) }
+        let(:to_project) { fork_project(@from_project, @to_user, namespace: @to_user.namespace) }
 
         it { expect(to_project).to be_persisted }
         it { expect(to_project.errors).to be_empty }
@@ -93,7 +94,7 @@ 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)
+        @to_project = fork_project(@from_project, @to_user, namespace: @to_namespace)
         expect(@existing_project).to be_persisted
 
         expect(@to_project).not_to be_persisted
@@ -115,7 +116,7 @@ describe Projects::ForkService do
       end
 
       it 'does not allow creation' do
-        to_project = fork_project(@from_project, @to_user)
+        to_project = fork_project(@from_project, @to_user, namespace: @to_user.namespace)
 
         expect(to_project).not_to be_persisted
         expect(to_project.errors.messages).to have_key(:base)
@@ -209,9 +210,4 @@ describe Projects::ForkService do
       end
     end
   end
-
-  def fork_project(from_project, user, params = {})
-    allow(RepositoryForkWorker).to receive(:perform_async).and_return(true)
-    Projects::ForkService.new(from_project, user, params).execute
-  end
 end

spec/services/projects/update_service_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 
 describe Projects::UpdateService, '#execute' do
   include StubConfiguration
+  include ProjectForksHelper
+
   let(:gitlab_shell) { Gitlab::Shell.new }
   let(:user) { create(:user) }
   let(:admin) { create(:admin) }
@@ -77,13 +79,7 @@ describe Projects::UpdateService, '#execute' do
 
   describe 'when updating project that has forks' do
     let(:project) { create(:project, :internal) }
-    let(:forked_project) { create(:forked_project_with_submodules, :internal) }
-
-    before do
-      forked_project.build_forked_project_link(forked_to_project_id: forked_project.id,
-                                               forked_from_project_id: project.id)
-      forked_project.save
-    end
+    let(:forked_project) { fork_project(project) }
 
     it 'updates forks visibility level when parent set to more restrictive' do
       opts = { visibility_level: Gitlab::VisibilityLevel::PRIVATE }

spec/services/system_note_service_spec.rb

 require 'spec_helper'
 
 describe SystemNoteService do
+  include ProjectForksHelper
   include Gitlab::Routing
 
   set(:group)    { create(:group) }
@@ -618,14 +619,7 @@ describe SystemNoteService do
 
     context 'commit with cross-reference from fork' do
       let(:author2) { create(:project_member, :reporter, user: create(:user), project: project).user }
-      let(:forked_project) do
-        fp = Projects::ForkService.new(project, author2).execute
-        # The call to project.repository.after_import in RepositoryForkWorker does
-        # not reset the @exists variable of @fork_project.repository so we have to
-        # explicitely call this method to clear the @exists variable.
-        fp.repository.after_import
-        fp
-      end
+      let(:forked_project) { fork_project(project, author2, repository: true) }
       let(:commit2) { forked_project.commit }
 
       before do

spec/support/project_forks_helper.rb

+module ProjectForksHelper
+  def fork_project(project, user = nil, params = {})
+    # Load the `fork_network` for the project to fork as there might be one that
+    # wasn't loaded yet.
+    project.reload unless project.fork_network
+
+    unless user
+      user = create(:user)
+      project.add_developer(user)
+    end
+
+    unless params[:namespace] || params[:namespace_id]
+      params[:namespace] = create(:group)
+      params[:namespace].add_owner(user)
+    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)
+      shell = double('gitlab_shell', fork_repository: true)
+      allow(service).to receive(:gitlab_shell).and_return(shell)
+    end
+
+    forked_project = service.execute
+
+    # Reload the both projects so they know about their newly created fork_network
+    if forked_project.persisted?
+      project.reload
+      forked_project.reload
+    end
+
+    if create_repository
+      # The call to project.repository.after_import in RepositoryForkWorker does
+      # not reset the @exists variable of this forked_project.repository
+      # so we have to explicitely call this method to clear the @exists variable.
+      # of the instance we're returning here.
+      forked_project.repository.after_import
+
+      # We can't leave the hooks in place after a fork, as those would fail in tests
+      # The "internal" API is not available
+      FileUtils.rm_rf("#{forked_project.repository.path}/hooks")
+    end
+
+    forked_project
+  end
+
+  def fork_project_with_submodules(project, user = nil, params = {})
+    forked_project = fork_project(project, user, params)
+    TestEnv.copy_repo(forked_project,
+                      bare_repo: TestEnv.forked_repo_path_bare,
+                      refs: TestEnv::FORKED_BRANCH_SHA)
+    forked_project.repository.after_import
+    forked_project
+  end
+end

spec/views/projects/merge_requests/_commits.html.haml_spec.rb

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 describe 'projects/merge_requests/_commits.html.haml' do
   include Devise::Test::ControllerHelpers
+  include ProjectForksHelper
 
   let(:user) { create(:user) }
-  let(:target_project) { create(:project, :repository) }
-  let(:source_project) { create(:project, :repository, forked_from_project: target_project) }
+  let(:target_project) { create(:project, :public, :repository) }
+  let(:source_project) { fork_project(target_project, user, repository: true) }
 
   let(:merge_request) do
     create(:merge_request, :simple,

spec/views/projects/merge_requests/edit.html.haml_spec.rb

@@ -2,16 +2,19 @@ require 'spec_helper'
 
 describe 'projects/merge_requests/edit.html.haml' do
   include Devise::Test::ControllerHelpers
+  include ProjectForksHelper
 
   let(:user) { create(:user) }
   let(:project) { create(:project, :repository) }
-  let(:fork_project) { create(:project, :repository, forked_from_project: project) }
-  let(:unlink_project) { Projects::UnlinkForkService.new(fork_project, user) }
+  let(:forked_project) { fork_project(project, user, repository: true) }
+  let(:unlink_project) { Projects::UnlinkForkService.new(forked_project, user) }
   let(:milestone) { create(:milestone, project: project) }
 
   let(:closed_merge_request) do
+    project.add_developer(user)
+
     create(:closed_merge_request,
-      source_project: fork_project,
+      source_project: forked_project,
       target_project: project,
       author: user,
       assignee: user,

spec/views/projects/merge_requests/show.html.haml_spec.rb

@@ -2,16 +2,17 @@ require 'spec_helper'
 
 describe 'projects/merge_requests/show.html.haml' do
   include Devise::Test::ControllerHelpers
+  include ProjectForksHelper
 
   let(:user) { create(:user) }
-  let(:project) { create(:project, :repository) }
-  let(:fork_project) { create(:project, :repository, forked_from_project: project) }
-  let(:unlink_project) { Projects::UnlinkForkService.new(fork_project, user) }
+  let(:project) { create(:project, :public, :repository) }
+  let(:forked_project) { fork_project(project, user, repository: true) }
+  let(:unlink_project) { Projects::UnlinkForkService.new(forked_project, user) }
   let(:note) { create(:note_on_merge_request, project: project, noteable: closed_merge_request) }
 
   let(:closed_merge_request) do
     create(:closed_merge_request,
-      source_project: fork_project,
+      source_project: forked_project,
       target_project: project,
       author: user)
   end
@@ -52,7 +53,9 @@ describe 'projects/merge_requests/show.html.haml' do
   context 'when the merge request is open' do
     it 'closes the merge request if the source project does not exist' do
       closed_merge_request.update_attributes(state: 'open')
-      fork_project.destroy
+      forked_project.destroy
+      # Reload merge request so MergeRequest#source_project turns to `nil`
+      closed_merge_request.reload
 
       render
 

spec/workers/namespaceless_project_destroy_worker_spec.rb

 require 'spec_helper'
 
 describe NamespacelessProjectDestroyWorker do
+  include ProjectForksHelper
+
   subject { described_class.new }
 
   before do
@@ -55,9 +57,11 @@ describe NamespacelessProjectDestroyWorker do
 
       context 'project forked from another' do
         let!(:parent_project) { create(:project) }
-
-        before do
-          create(:forked_project_link, forked_to_project: project, forked_from_project: parent_project)
+        let(:project) do
+          namespaceless_project = fork_project(parent_project)
+          namespaceless_project.namespace_id = nil
+          namespaceless_project.save(validate: false)
+          namespaceless_project
         end
 
         it 'closes open merge requests' do