debian-mirror-gitlab/spec/services/projects/fork_service_spec.rb

356 lines
13 KiB
Ruby
Raw Normal View History

2019-07-31 22:56:46 +05:30
# frozen_string_literal: true
2015-04-26 12:48:37 +05:30
require 'spec_helper'
2017-09-10 17:25:29 +05:30
describe Projects::ForkService do
2018-03-17 18:26:18 +05:30
include ProjectForksHelper
2019-02-15 15:39:39 +05:30
include Gitlab::ShellAdapter
2018-03-17 18:26:18 +05:30
context 'when forking a new project' do
describe 'fork by user' do
before do
@from_user = create(:user)
@from_namespace = @from_user.namespace
2018-11-08 19:23:39 +05:30
avatar = fixture_file_upload("spec/fixtures/dk.png", "image/png")
2018-03-17 18:26:18 +05:30
@from_project = create(:project,
:repository,
creator_id: @from_user.id,
namespace: @from_namespace,
star_count: 107,
avatar: avatar,
description: 'wow such project')
@to_user = create(:user)
@to_namespace = @to_user.namespace
@from_project.add_user(@to_user, :developer)
end
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
context 'fork project' do
context 'when forker is a guest' do
before do
@guest = create(:user)
@from_project.add_user(@guest, :guest)
end
subject { fork_project(@from_project, @guest) }
2015-04-26 12:48:37 +05:30
2018-03-17 18:26:18 +05:30
it { is_expected.not_to be_persisted }
it { expect(subject.errors[:forked_from_project_id]).to eq(['is forbidden']) }
2018-12-13 13:39:08 +05:30
it 'does not create a fork network' do
expect { subject }.not_to change { @from_project.reload.fork_network }
end
2016-10-01 15:18:49 +05:30
end
2018-03-17 18:26:18 +05:30
describe "successfully creates project in the user namespace" do
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 }
it { expect(to_project.owner).to eq(@to_user) }
it { expect(to_project.namespace).to eq(@to_user.namespace) }
it { expect(to_project.star_count).to be_zero }
it { expect(to_project.description).to eq(@from_project.description) }
it { expect(to_project.avatar.file).to be_exists }
# This test is here because we had a bug where the from-project lost its
# avatar after being forked.
# https://gitlab.com/gitlab-org/gitlab-ce/issues/26158
it "after forking the from-project still has its avatar" do
# If we do not fork the project first we cannot detect the bug.
expect(to_project).to be_persisted
expect(@from_project.avatar.file).to be_exists
end
it 'flushes the forks count cache of the source project' do
expect(@from_project.forks_count).to be_zero
fork_project(@from_project, @to_user)
expect(@from_project.forks_count).to eq(1)
end
it 'creates a fork network with the new project and the root project set' do
to_project
fork_network = @from_project.reload.fork_network
2016-10-01 15:18:49 +05:30
2018-03-17 18:26:18 +05:30
expect(fork_network).not_to be_nil
expect(fork_network.root_project).to eq(@from_project)
expect(fork_network.projects).to contain_exactly(@from_project, to_project)
end
2018-12-13 13:39:08 +05:30
it 'imports the repository of the forked project' do
to_project = fork_project(@from_project, @to_user, repository: true)
expect(to_project.empty_repo?).to be_falsy
end
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
context 'creating a fork of a fork' do
let(:from_forked_project) { fork_project(@from_project, @to_user) }
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) }
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
it 'sets the root of the network to the root project' do
expect(to_project.fork_network.root_project).to eq(@from_project)
end
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
it 'sets the forked_from_project on the membership' do
expect(to_project.fork_network_member.forked_from_project).to eq(from_forked_project)
end
2017-09-10 17:25:29 +05:30
end
2015-04-26 12:48:37 +05:30
end
2018-03-17 18:26:18 +05:30
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)
expect(@existing_project).to be_persisted
2016-10-01 15:18:49 +05:30
2018-03-17 18:26:18 +05:30
expect(@to_project).not_to be_persisted
expect(@to_project.errors[:name]).to eq(['has already been taken'])
expect(@to_project.errors[:path]).to eq(['has already been taken'])
end
2015-04-26 12:48:37 +05:30
end
2019-09-04 21:01:54 +05:30
context 'repository in legacy storage already exists' do
2018-03-17 18:26:18 +05:30
let(:repository_storage) { 'default' }
2018-05-09 12:01:36 +05:30
let(:repository_storage_path) { Gitlab.config.repositories.storages[repository_storage].legacy_disk_path }
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
before do
2019-09-04 21:01:54 +05:30
stub_application_setting(hashed_storage_enabled: false)
2019-03-02 22:35:43 +05:30
gitlab_shell.create_repository(repository_storage, "#{@to_user.namespace.full_path}/#{@from_project.path}", "#{@to_user.namespace.full_path}/#{@from_project.path}")
2018-03-17 18:26:18 +05:30
end
after do
2018-10-15 14:42:47 +05:30
gitlab_shell.remove_repository(repository_storage, "#{@to_user.namespace.full_path}/#{@from_project.path}")
2018-03-17 18:26:18 +05:30
end
it 'does not allow creation' do
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)
expect(to_project.errors.messages[:base].first).to match('There is already a repository with that name on disk')
end
2017-09-10 17:25:29 +05:30
end
2018-03-17 18:26:18 +05:30
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)
expect(@to_project.builds_enabled?).to be_truthy
end
2017-09-10 17:25:29 +05:30
end
2019-09-04 21:01:54 +05:30
context "CI/CD settings" do
let(:to_project) { fork_project(@from_project, @to_user) }
context "when origin has git depth specified" do
before do
@from_project.update(ci_default_git_depth: 42)
end
it "inherits default_git_depth from the origin project" do
expect(to_project.ci_default_git_depth).to eq(42)
end
end
context "when origin does not define git depth" do
before do
@from_project.update!(ci_default_git_depth: nil)
end
it "the fork has git depth set to 0" do
expect(to_project.ci_default_git_depth).to eq(0)
end
end
end
2018-03-17 18:26:18 +05:30
context "when project has restricted visibility level" do
context "and only one visibility level is restricted" do
before do
2018-11-18 11:00:15 +05:30
@from_project.update(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
2018-03-17 18:26:18 +05:30
stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::INTERNAL])
end
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
it "creates fork with lowest level" do
forked_project = fork_project(@from_project, @to_user)
expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
end
end
context "and all visibility levels are restricted" do
before do
stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC, Gitlab::VisibilityLevel::INTERNAL, Gitlab::VisibilityLevel::PRIVATE])
end
it "creates fork with private visibility levels" do
forked_project = fork_project(@from_project, @to_user)
expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
end
end
2017-09-10 17:25:29 +05:30
end
end
2018-03-17 18:26:18 +05:30
describe 'fork to namespace' do
before do
@group_owner = create(:user)
@developer = create(:user)
@project = create(:project, :repository,
creator_id: @group_owner.id,
star_count: 777,
description: 'Wow, such a cool project!')
@group = create(:group)
@group.add_user(@group_owner, GroupMember::OWNER)
@group.add_user(@developer, GroupMember::DEVELOPER)
@project.add_user(@developer, :developer)
@project.add_user(@group_owner, :developer)
@opts = { namespace: @group }
2015-04-26 12:48:37 +05:30
end
2018-03-17 18:26:18 +05:30
context 'fork project for group' do
it 'group owner successfully forks project into the group' do
to_project = fork_project(@project, @group_owner, @opts)
2018-03-17 18:26:18 +05:30
expect(to_project).to be_persisted
expect(to_project.errors).to be_empty
expect(to_project.owner).to eq(@group)
expect(to_project.namespace).to eq(@group)
expect(to_project.name).to eq(@project.name)
expect(to_project.path).to eq(@project.path)
expect(to_project.description).to eq(@project.description)
expect(to_project.star_count).to be_zero
end
end
2018-03-17 18:26:18 +05:30
context 'fork project for group when user not owner' do
it 'group developer fails to fork project into the group' do
to_project = fork_project(@project, @developer, @opts)
expect(to_project.errors[:namespace]).to eq(['is not valid'])
end
end
2018-03-17 18:26:18 +05:30
context 'project already exists in group' do
it 'fails due to validation, not transaction failure' do
existing_project = create(:project, :repository,
name: @project.name,
namespace: @group)
to_project = fork_project(@project, @group_owner, @opts)
expect(existing_project.persisted?).to be_truthy
expect(to_project.errors[:name]).to eq(['has already been taken'])
expect(to_project.errors[:path]).to eq(['has already been taken'])
end
2018-03-17 18:26:18 +05:30
end
context 'when the namespace has a lower visibility level than the project' do
it 'creates the project with the lower visibility level' do
public_project = create(:project, :public)
private_group = create(:group, :private)
group_owner = create(:user)
private_group.add_owner(group_owner)
2018-03-17 18:26:18 +05:30
forked_project = fork_project(public_project, group_owner, namespace: private_group)
expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
end
end
end
2015-04-26 12:48:37 +05:30
end
2019-02-15 15:39:39 +05:30
context 'when forking with object pools' do
let(:fork_from_project) { create(:project, :public) }
let(:forker) { create(:user) }
before do
stub_feature_flags(object_pools: true)
end
context 'when no pool exists' do
it 'creates a new object pool' do
forked_project = fork_project(fork_from_project, forker)
expect(forked_project.pool_repository).to eq(fork_from_project.pool_repository)
end
end
context 'when a pool already exists' 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)
expect(forked_project.pool_repository).to eq(fork_from_project.pool_repository)
end
end
end
2018-03-17 18:26:18 +05:30
context 'when linking fork to an existing project' do
let(:fork_from_project) { create(:project, :public) }
let(:fork_to_project) { create(:project, :public) }
let(:user) { create(:user) }
subject { described_class.new(fork_from_project, user) }
def forked_from_project(project)
project.fork_network_member&.forked_from_project
2015-04-26 12:48:37 +05:30
end
2018-03-17 18:26:18 +05:30
context 'if project is already forked' do
it 'does not create fork relation' do
allow(fork_to_project).to receive(:forked?).and_return(true)
expect(forked_from_project(fork_to_project)).to be_nil
expect(subject.execute(fork_to_project)).to be_nil
expect(forked_from_project(fork_to_project)).to be_nil
2015-04-26 12:48:37 +05:30
end
end
2018-03-17 18:26:18 +05:30
context 'if project is not forked' do
it 'creates fork relation' do
2018-12-13 13:39:08 +05:30
expect(fork_to_project.forked?).to be_falsy
2018-03-17 18:26:18 +05:30
expect(forked_from_project(fork_to_project)).to be_nil
subject.execute(fork_to_project)
2018-12-13 13:39:08 +05:30
fork_to_project.reload
2018-03-17 18:26:18 +05:30
expect(fork_to_project.forked?).to be true
expect(forked_from_project(fork_to_project)).to eq fork_from_project
expect(fork_to_project.forked_from_project).to eq fork_from_project
2015-04-26 12:48:37 +05:30
end
2018-03-17 18:26:18 +05:30
it 'flushes the forks count cache of the source project' do
expect(fork_from_project.forks_count).to be_zero
subject.execute(fork_to_project)
expect(fork_from_project.forks_count).to eq(1)
2015-04-26 12:48:37 +05:30
end
2018-11-20 20:47:30 +05:30
it 'leaves no LFS objects dangling' do
create(:lfs_objects_project, project: fork_to_project)
expect { subject.execute(fork_to_project) }
.to change { fork_to_project.lfs_objects_projects.count }
.to(0)
end
2018-12-13 13:39:08 +05:30
context 'if the fork is not allowed' do
let(:fork_from_project) { create(:project, :private) }
it 'does not delete the LFS objects' do
create(:lfs_objects_project, project: fork_to_project)
expect { subject.execute(fork_to_project) }
.not_to change { fork_to_project.lfs_objects_projects.size }
end
end
2015-04-26 12:48:37 +05:30
end
end
end