2019-07-07 11:18:12 +05:30
|
|
|
# frozen_string_literal: true
|
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
require 'spec_helper'
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
RSpec.describe Ci::Pipeline, :mailer, factory_default: :keep do
|
2019-07-07 11:18:12 +05:30
|
|
|
include ProjectForksHelper
|
2019-09-04 21:01:54 +05:30
|
|
|
include StubRequests
|
2020-11-24 15:15:51 +05:30
|
|
|
include Ci::SourcePipelineHelpers
|
2019-07-07 11:18:12 +05:30
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
let_it_be(:user) { create(:user) }
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:namespace) { create_default(:namespace).freeze }
|
|
|
|
let_it_be(:project) { create_default(:project, :repository).freeze }
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
it_behaves_like 'having unique enum values'
|
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
it { is_expected.to belong_to(:project) }
|
2016-08-24 12:49:21 +05:30
|
|
|
it { is_expected.to belong_to(:user) }
|
2017-08-17 22:00:37 +05:30
|
|
|
it { is_expected.to belong_to(:auto_canceled_by) }
|
|
|
|
it { is_expected.to belong_to(:pipeline_schedule) }
|
2019-02-15 15:39:39 +05:30
|
|
|
it { is_expected.to belong_to(:merge_request) }
|
2019-12-04 20:38:33 +05:30
|
|
|
it { is_expected.to belong_to(:external_pull_request) }
|
2016-08-24 12:49:21 +05:30
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
it { is_expected.to have_many(:statuses) }
|
|
|
|
it { is_expected.to have_many(:trigger_requests) }
|
2017-09-10 17:25:29 +05:30
|
|
|
it { is_expected.to have_many(:variables) }
|
2016-06-16 23:09:34 +05:30
|
|
|
it { is_expected.to have_many(:builds) }
|
2020-06-23 00:09:42 +05:30
|
|
|
it { is_expected.to have_many(:bridges) }
|
|
|
|
it { is_expected.to have_many(:job_artifacts).through(:builds) }
|
2017-08-17 22:00:37 +05:30
|
|
|
it { is_expected.to have_many(:auto_canceled_pipelines) }
|
|
|
|
it { is_expected.to have_many(:auto_canceled_jobs) }
|
2019-12-21 20:55:43 +05:30
|
|
|
it { is_expected.to have_many(:sourced_pipelines) }
|
|
|
|
it { is_expected.to have_many(:triggered_pipelines) }
|
2021-02-11 23:33:58 +05:30
|
|
|
it { is_expected.to have_many(:pipeline_artifacts) }
|
2019-12-21 20:55:43 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
it { is_expected.to have_one(:chat_data) }
|
2019-12-21 20:55:43 +05:30
|
|
|
it { is_expected.to have_one(:source_pipeline) }
|
|
|
|
it { is_expected.to have_one(:triggered_by_pipeline) }
|
|
|
|
it { is_expected.to have_one(:source_job) }
|
2020-03-13 15:44:24 +05:30
|
|
|
it { is_expected.to have_one(:pipeline_config) }
|
2016-08-24 12:49:21 +05:30
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
it { is_expected.to respond_to :git_author_name }
|
|
|
|
it { is_expected.to respond_to :git_author_email }
|
|
|
|
it { is_expected.to respond_to :short_sha }
|
2018-03-17 18:26:18 +05:30
|
|
|
it { is_expected.to delegate_method(:full_path).to(:project).with_prefix }
|
2021-02-11 23:33:58 +05:30
|
|
|
|
|
|
|
describe 'validations' do
|
|
|
|
it { is_expected.to validate_presence_of(:sha) }
|
|
|
|
it { is_expected.to validate_presence_of(:status) }
|
|
|
|
end
|
2018-03-17 18:26:18 +05:30
|
|
|
|
|
|
|
describe 'associations' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-03-17 18:26:18 +05:30
|
|
|
it 'has a bidirectional relationship with projects' do
|
2019-02-15 15:39:39 +05:30
|
|
|
expect(described_class.reflect_on_association(:project).has_inverse?).to eq(:all_pipelines)
|
|
|
|
expect(Project.reflect_on_association(:all_pipelines).has_inverse?).to eq(:project)
|
|
|
|
expect(Project.reflect_on_association(:ci_pipelines).has_inverse?).to eq(:project)
|
|
|
|
end
|
2020-06-23 00:09:42 +05:30
|
|
|
|
|
|
|
describe '#latest_builds' do
|
|
|
|
it 'has a one to many relationship with its latest builds' do
|
|
|
|
_old_build = create(:ci_build, :retried, pipeline: pipeline)
|
|
|
|
latest_build = create(:ci_build, :expired, pipeline: pipeline)
|
|
|
|
|
|
|
|
expect(pipeline.latest_builds).to contain_exactly(latest_build)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#downloadable_artifacts' do
|
|
|
|
let(:build) { create(:ci_build, pipeline: pipeline) }
|
|
|
|
|
|
|
|
it 'returns downloadable artifacts that have not expired' do
|
|
|
|
downloadable_artifact = create(:ci_job_artifact, :codequality, job: build)
|
|
|
|
_expired_artifact = create(:ci_job_artifact, :junit, :expired, job: build)
|
|
|
|
_undownloadable_artifact = create(:ci_job_artifact, :trace, job: build)
|
|
|
|
|
|
|
|
expect(pipeline.downloadable_artifacts).to contain_exactly(downloadable_artifact)
|
|
|
|
end
|
|
|
|
end
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
2020-05-24 23:13:21 +05:30
|
|
|
describe '#set_status' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2020-05-24 23:13:21 +05:30
|
|
|
where(:from_status, :to_status) do
|
|
|
|
from_status_names = described_class.state_machines[:status].states.map(&:name)
|
|
|
|
to_status_names = from_status_names - [:created] # we never want to transition into created
|
|
|
|
|
|
|
|
from_status_names.product(to_status_names)
|
|
|
|
end
|
|
|
|
|
|
|
|
with_them do
|
|
|
|
it do
|
|
|
|
pipeline.status = from_status.to_s
|
|
|
|
|
|
|
|
if from_status != to_status
|
|
|
|
expect(pipeline.set_status(to_status.to_s))
|
|
|
|
.to eq(true)
|
|
|
|
else
|
|
|
|
expect(pipeline.set_status(to_status.to_s))
|
|
|
|
.to eq(false), "loopback transitions are not allowed"
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-03-02 22:35:43 +05:30
|
|
|
describe '.processables' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2019-03-02 22:35:43 +05:30
|
|
|
before do
|
|
|
|
create(:ci_build, name: 'build', pipeline: pipeline)
|
|
|
|
create(:ci_bridge, name: 'bridge', pipeline: pipeline)
|
|
|
|
create(:commit_status, name: 'commit status', pipeline: pipeline)
|
|
|
|
create(:generic_commit_status, name: 'generic status', pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'has an association with processable CI/CD entities' do
|
|
|
|
pipeline.processables.pluck('name').yield_self do |processables|
|
|
|
|
expect(processables).to match_array %w[build bridge]
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'makes it possible to append a new processable' do
|
|
|
|
pipeline.processables << build(:ci_bridge)
|
|
|
|
|
|
|
|
pipeline.save!
|
|
|
|
|
|
|
|
expect(pipeline.processables.reload.count).to eq 3
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
describe '.for_iid' do
|
|
|
|
subject { described_class.for_iid(iid) }
|
|
|
|
|
|
|
|
let(:iid) { '1234' }
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, iid: '1234') }
|
|
|
|
|
|
|
|
it 'returns the pipeline' do
|
|
|
|
is_expected.to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
describe '.for_sha' do
|
|
|
|
subject { described_class.for_sha(sha) }
|
|
|
|
|
|
|
|
let(:sha) { 'abc' }
|
2021-04-17 20:07:23 +05:30
|
|
|
|
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, sha: 'abc') }
|
2019-07-07 11:18:12 +05:30
|
|
|
|
|
|
|
it 'returns the pipeline' do
|
|
|
|
is_expected.to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when argument is array' do
|
|
|
|
let(:sha) { %w[abc def] }
|
|
|
|
let!(:pipeline_2) { create(:ci_pipeline, sha: 'def') }
|
|
|
|
|
|
|
|
it 'returns the pipelines' do
|
|
|
|
is_expected.to contain_exactly(pipeline, pipeline_2)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when sha is empty' do
|
|
|
|
let(:sha) { nil }
|
|
|
|
|
|
|
|
it 'does not return anything' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '.for_source_sha' do
|
|
|
|
subject { described_class.for_source_sha(source_sha) }
|
|
|
|
|
|
|
|
let(:source_sha) { 'abc' }
|
2021-04-17 20:07:23 +05:30
|
|
|
|
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, source_sha: 'abc') }
|
2019-07-07 11:18:12 +05:30
|
|
|
|
|
|
|
it 'returns the pipeline' do
|
|
|
|
is_expected.to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when argument is array' do
|
|
|
|
let(:source_sha) { %w[abc def] }
|
|
|
|
let!(:pipeline_2) { create(:ci_pipeline, source_sha: 'def') }
|
|
|
|
|
|
|
|
it 'returns the pipelines' do
|
|
|
|
is_expected.to contain_exactly(pipeline, pipeline_2)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when source_sha is empty' do
|
|
|
|
let(:source_sha) { nil }
|
|
|
|
|
|
|
|
it 'does not return anything' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '.for_sha_or_source_sha' do
|
|
|
|
subject { described_class.for_sha_or_source_sha(sha) }
|
|
|
|
|
|
|
|
let(:sha) { 'abc' }
|
|
|
|
|
|
|
|
context 'when sha is matched' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, sha: sha) }
|
|
|
|
|
|
|
|
it 'returns the pipeline' do
|
|
|
|
is_expected.to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when source sha is matched' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, source_sha: sha) }
|
|
|
|
|
|
|
|
it 'returns the pipeline' do
|
|
|
|
is_expected.to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when both sha and source sha are not matched' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, sha: 'bcd', source_sha: 'bcd') }
|
|
|
|
|
|
|
|
it 'does not return anything' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
describe '.for_branch' do
|
|
|
|
subject { described_class.for_branch(branch) }
|
|
|
|
|
|
|
|
let(:branch) { 'master' }
|
2021-04-17 20:07:23 +05:30
|
|
|
|
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, ref: 'master') }
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
it 'returns the pipeline' do
|
|
|
|
is_expected.to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with tag pipeline' do
|
|
|
|
let(:branch) { 'v1.0' }
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, ref: 'v1.0', tag: true) }
|
|
|
|
|
|
|
|
it 'returns nothing' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
describe '.ci_sources' do
|
|
|
|
subject { described_class.ci_sources }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:push_pipeline) { build(:ci_pipeline, source: :push) }
|
|
|
|
let(:web_pipeline) { build(:ci_pipeline, source: :web) }
|
|
|
|
let(:api_pipeline) { build(:ci_pipeline, source: :api) }
|
|
|
|
let(:webide_pipeline) { build(:ci_pipeline, source: :webide) }
|
|
|
|
let(:child_pipeline) { build(:ci_pipeline, source: :parent_pipeline) }
|
|
|
|
let(:pipelines) { [push_pipeline, web_pipeline, api_pipeline, webide_pipeline, child_pipeline] }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it 'contains pipelines having CI only sources' do
|
2021-04-17 20:07:23 +05:30
|
|
|
pipelines.map(&:save!)
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
expect(subject).to contain_exactly(push_pipeline, web_pipeline, api_pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'filters on expected sources' do
|
|
|
|
expect(::Enums::Ci::Pipeline.ci_sources.keys).to contain_exactly(
|
|
|
|
*%i[unknown push web trigger schedule api external pipeline chat
|
|
|
|
merge_request_event external_pull_request_event])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
describe '.ci_branch_sources' do
|
|
|
|
subject { described_class.ci_branch_sources }
|
|
|
|
|
|
|
|
let_it_be(:push_pipeline) { create(:ci_pipeline, source: :push) }
|
|
|
|
let_it_be(:web_pipeline) { create(:ci_pipeline, source: :web) }
|
|
|
|
let_it_be(:api_pipeline) { create(:ci_pipeline, source: :api) }
|
|
|
|
let_it_be(:webide_pipeline) { create(:ci_pipeline, source: :webide) }
|
|
|
|
let_it_be(:child_pipeline) { create(:ci_pipeline, source: :parent_pipeline) }
|
|
|
|
let_it_be(:merge_request_pipeline) { create(:ci_pipeline, :detached_merge_request_pipeline) }
|
|
|
|
|
|
|
|
it 'contains pipelines having CI only sources' do
|
|
|
|
expect(subject).to contain_exactly(push_pipeline, web_pipeline, api_pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'filters on expected sources' do
|
|
|
|
expect(::Enums::Ci::Pipeline.ci_branch_sources.keys).to contain_exactly(
|
|
|
|
*%i[unknown push web trigger schedule api external pipeline chat
|
|
|
|
external_pull_request_event])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '.outside_pipeline_family' do
|
|
|
|
subject(:outside_pipeline_family) { described_class.outside_pipeline_family(upstream_pipeline) }
|
|
|
|
|
|
|
|
let(:upstream_pipeline) { create(:ci_pipeline, project: project) }
|
|
|
|
let(:child_pipeline) { create(:ci_pipeline, project: project) }
|
|
|
|
|
|
|
|
let!(:other_pipeline) { create(:ci_pipeline, project: project) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create(:ci_sources_pipeline,
|
|
|
|
source_job: create(:ci_build, pipeline: upstream_pipeline),
|
|
|
|
source_project: project,
|
|
|
|
pipeline: child_pipeline,
|
|
|
|
project: project)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'only returns pipelines outside pipeline family' do
|
|
|
|
expect(outside_pipeline_family).to contain_exactly(other_pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '.before_pipeline' do
|
|
|
|
subject(:before_pipeline) { described_class.before_pipeline(child_pipeline) }
|
|
|
|
|
|
|
|
let!(:older_other_pipeline) { create(:ci_pipeline, project: project) }
|
|
|
|
|
|
|
|
let!(:upstream_pipeline) { create(:ci_pipeline, project: project) }
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:child_pipeline) { create(:ci_pipeline, child_of: upstream_pipeline) }
|
2020-07-28 23:09:34 +05:30
|
|
|
|
|
|
|
let!(:other_pipeline) { create(:ci_pipeline, project: project) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create(:ci_sources_pipeline,
|
|
|
|
source_job: create(:ci_build, pipeline: upstream_pipeline),
|
|
|
|
source_project: project,
|
|
|
|
pipeline: child_pipeline,
|
|
|
|
project: project)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'only returns older pipelines outside pipeline family' do
|
|
|
|
expect(before_pipeline).to contain_exactly(older_other_pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
describe '#merge_request?' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, merge_request: merge_request) }
|
|
|
|
let(:merge_request) { create(:merge_request) }
|
|
|
|
|
|
|
|
it 'returns true' do
|
|
|
|
expect(pipeline).to be_merge_request
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when merge request is nil' do
|
|
|
|
let(:merge_request) { nil }
|
|
|
|
|
|
|
|
it 'returns false' do
|
|
|
|
expect(pipeline).not_to be_merge_request
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
describe '#detached_merge_request_pipeline?' do
|
|
|
|
subject { pipeline.detached_merge_request_pipeline? }
|
|
|
|
|
|
|
|
let!(:pipeline) do
|
|
|
|
create(:ci_pipeline, source: :merge_request_event, merge_request: merge_request, target_sha: target_sha)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:merge_request) { create(:merge_request) }
|
|
|
|
let(:target_sha) { nil }
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
|
|
|
|
context 'when target sha exists' do
|
|
|
|
let(:target_sha) { merge_request.target_branch_sha }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsy }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '#merged_result_pipeline?' do
|
|
|
|
subject { pipeline.merged_result_pipeline? }
|
2019-07-07 11:18:12 +05:30
|
|
|
|
|
|
|
let!(:pipeline) do
|
|
|
|
create(:ci_pipeline, source: :merge_request_event, merge_request: merge_request, target_sha: target_sha)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:merge_request) { create(:merge_request) }
|
|
|
|
let(:target_sha) { merge_request.target_branch_sha }
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
|
|
|
|
context 'when target sha is empty' do
|
|
|
|
let(:target_sha) { nil }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsy }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#merge_request_ref?' do
|
|
|
|
subject { pipeline.merge_request_ref? }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
it 'calls MergeRequest#merge_request_ref?' do
|
|
|
|
expect(MergeRequest).to receive(:merge_request_ref?).with(pipeline.ref)
|
|
|
|
|
|
|
|
subject
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-12-04 20:38:33 +05:30
|
|
|
describe '#merge_request_event_type' do
|
|
|
|
subject { pipeline.merge_request_event_type }
|
|
|
|
|
2020-01-01 13:55:28 +05:30
|
|
|
let(:pipeline) { merge_request.all_pipelines.last }
|
2019-12-04 20:38:33 +05:30
|
|
|
|
|
|
|
context 'when pipeline is merge request pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
let(:merge_request) { create(:merge_request, :with_merge_request_pipeline) }
|
2019-12-04 20:38:33 +05:30
|
|
|
|
|
|
|
it { is_expected.to eq(:merged_result) }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is detached merge request pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
let(:merge_request) { create(:merge_request, :with_detached_merge_request_pipeline) }
|
2019-12-04 20:38:33 +05:30
|
|
|
|
|
|
|
it { is_expected.to eq(:detached) }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
describe '#legacy_detached_merge_request_pipeline?' do
|
|
|
|
subject { pipeline.legacy_detached_merge_request_pipeline? }
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
let_it_be(:merge_request) { create(:merge_request) }
|
2019-07-07 11:18:12 +05:30
|
|
|
let(:ref) { 'feature' }
|
|
|
|
let(:target_sha) { nil }
|
|
|
|
|
|
|
|
let(:pipeline) do
|
|
|
|
build(:ci_pipeline, source: :merge_request_event, merge_request: merge_request, ref: ref, target_sha: target_sha)
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
|
|
|
|
context 'when pipeline ref is a merge request ref' do
|
|
|
|
let(:ref) { 'refs/merge-requests/1/head' }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsy }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when target sha is set' do
|
|
|
|
let(:target_sha) { 'target-sha' }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsy }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#matches_sha_or_source_sha?' do
|
|
|
|
subject { pipeline.matches_sha_or_source_sha?(sample_sha) }
|
|
|
|
|
|
|
|
let(:sample_sha) { Digest::SHA1.hexdigest(SecureRandom.hex) }
|
|
|
|
|
|
|
|
context 'when sha matches' do
|
|
|
|
let(:pipeline) { build(:ci_pipeline, sha: sample_sha) }
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when source_sha matches' do
|
|
|
|
let(:pipeline) { build(:ci_pipeline, source_sha: sample_sha) }
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when both sha and source_sha do not matche' do
|
|
|
|
let(:pipeline) { build(:ci_pipeline, sha: 'test', source_sha: 'test') }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsy }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#source_ref' do
|
|
|
|
subject { pipeline.source_ref }
|
|
|
|
|
|
|
|
let(:pipeline) { create(:ci_pipeline, ref: 'feature') }
|
|
|
|
|
|
|
|
it 'returns source ref' do
|
|
|
|
is_expected.to eq('feature')
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the pipeline is a detached merge request pipeline' do
|
|
|
|
let(:merge_request) { create(:merge_request) }
|
|
|
|
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline, source: :merge_request_event, merge_request: merge_request, ref: merge_request.ref_path)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns source ref' do
|
|
|
|
is_expected.to eq(merge_request.source_branch)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#source_ref_slug' do
|
|
|
|
subject { pipeline.source_ref_slug }
|
|
|
|
|
|
|
|
let(:pipeline) { create(:ci_pipeline, ref: 'feature') }
|
|
|
|
|
|
|
|
it 'slugifies with the source ref' do
|
|
|
|
expect(Gitlab::Utils).to receive(:slugify).with('feature')
|
|
|
|
|
|
|
|
subject
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the pipeline is a detached merge request pipeline' do
|
|
|
|
let(:merge_request) { create(:merge_request) }
|
|
|
|
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline, source: :merge_request_event, merge_request: merge_request, ref: merge_request.ref_path)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'slugifies with the source ref of the merge request' do
|
|
|
|
expect(Gitlab::Utils).to receive(:slugify).with(merge_request.source_branch)
|
|
|
|
|
|
|
|
subject
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '.with_reports' do
|
|
|
|
context 'when pipeline has a test report' do
|
2020-04-08 14:13:33 +05:30
|
|
|
subject { described_class.with_reports(Ci::JobArtifact.test_reports) }
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
let!(:pipeline_with_report) { create(:ci_pipeline, :with_test_reports) }
|
|
|
|
|
|
|
|
it 'selects the pipeline' do
|
|
|
|
is_expected.to eq([pipeline_with_report])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-08 14:13:33 +05:30
|
|
|
context 'when pipeline has a coverage report' do
|
|
|
|
subject { described_class.with_reports(Ci::JobArtifact.coverage_reports) }
|
|
|
|
|
|
|
|
let!(:pipeline_with_report) { create(:ci_pipeline, :with_coverage_reports) }
|
|
|
|
|
|
|
|
it 'selects the pipeline' do
|
|
|
|
is_expected.to eq([pipeline_with_report])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-05-24 23:13:21 +05:30
|
|
|
context 'when pipeline has an accessibility report' do
|
|
|
|
subject { described_class.with_reports(Ci::JobArtifact.accessibility_reports) }
|
|
|
|
|
|
|
|
let(:pipeline_with_report) { create(:ci_pipeline, :with_accessibility_reports) }
|
|
|
|
|
|
|
|
it 'selects the pipeline' do
|
|
|
|
is_expected.to eq([pipeline_with_report])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'when pipeline has a codequality report' do
|
|
|
|
subject { described_class.with_reports(Ci::JobArtifact.codequality_reports) }
|
|
|
|
|
|
|
|
let(:pipeline_with_report) { create(:ci_pipeline, :with_codequality_reports) }
|
|
|
|
|
|
|
|
it 'selects the pipeline' do
|
|
|
|
is_expected.to eq([pipeline_with_report])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-05-24 23:13:21 +05:30
|
|
|
context 'when pipeline has a terraform report' do
|
|
|
|
it 'selects the pipeline' do
|
|
|
|
pipeline_with_report = create(:ci_pipeline, :with_terraform_reports)
|
|
|
|
|
|
|
|
expect(described_class.with_reports(Ci::JobArtifact.terraform_reports)).to eq(
|
|
|
|
[pipeline_with_report]
|
|
|
|
)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
context 'when pipeline does not have metrics reports' do
|
2020-04-08 14:13:33 +05:30
|
|
|
subject { described_class.with_reports(Ci::JobArtifact.test_reports) }
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
let!(:pipeline_without_report) { create(:ci_empty_pipeline) }
|
|
|
|
|
|
|
|
it 'does not select the pipeline' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '.merge_request_event' do
|
|
|
|
subject { described_class.merge_request_event }
|
2019-02-15 15:39:39 +05:30
|
|
|
|
|
|
|
context 'when there is a merge request pipeline' do
|
2019-07-07 11:18:12 +05:30
|
|
|
let!(:pipeline) { create(:ci_pipeline, source: :merge_request_event, merge_request: merge_request) }
|
2019-02-15 15:39:39 +05:30
|
|
|
let(:merge_request) { create(:merge_request) }
|
|
|
|
|
|
|
|
it 'returns merge request pipeline first' do
|
|
|
|
expect(subject).to eq([pipeline])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when there are no merge request pipelines' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, source: :push) }
|
|
|
|
|
|
|
|
it 'returns empty array' do
|
|
|
|
expect(subject).to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-11-08 19:23:39 +05:30
|
|
|
describe 'modules' do
|
|
|
|
it_behaves_like 'AtomicInternalId', validate_presence: false do
|
|
|
|
let(:internal_id_attribute) { :iid }
|
|
|
|
let(:instance) { build(:ci_pipeline) }
|
|
|
|
let(:scope) { :project }
|
|
|
|
let(:scope_attrs) { { project: instance.project } }
|
|
|
|
let(:usage) { :ci_pipelines }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-09-10 17:25:29 +05:30
|
|
|
describe '#source' do
|
|
|
|
context 'when creating new pipeline' do
|
|
|
|
let(:pipeline) do
|
2021-04-17 20:07:23 +05:30
|
|
|
build(:ci_empty_pipeline, :created, project: project, source: nil)
|
2017-09-10 17:25:29 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it "prevents from creating an object" do
|
|
|
|
expect(pipeline).not_to be_valid
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when updating existing pipeline' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2017-09-10 17:25:29 +05:30
|
|
|
before do
|
|
|
|
pipeline.update_attribute(:source, nil)
|
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'object is valid' do
|
2017-09-10 17:25:29 +05:30
|
|
|
expect(pipeline).to be_valid
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
describe '#block' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
it 'changes pipeline status to manual' do
|
|
|
|
expect(pipeline.block).to be true
|
|
|
|
expect(pipeline.reload).to be_manual
|
|
|
|
expect(pipeline.reload).to be_blocked
|
|
|
|
end
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
|
2018-12-05 23:21:45 +05:30
|
|
|
describe '#delay' do
|
|
|
|
subject { pipeline.delay }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_pipeline, :created) }
|
2018-12-05 23:21:45 +05:30
|
|
|
|
|
|
|
it 'changes pipeline status to schedule' do
|
|
|
|
subject
|
|
|
|
|
|
|
|
expect(pipeline).to be_scheduled
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
describe '#valid_commit_sha' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build_stubbed(:ci_empty_pipeline, :created, project: project) }
|
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
context 'commit.sha can not start with 00000000' do
|
|
|
|
before do
|
|
|
|
pipeline.sha = '0' * 40
|
|
|
|
pipeline.valid_commit_sha
|
|
|
|
end
|
|
|
|
|
|
|
|
it('commit errors should not be empty') { expect(pipeline.errors).not_to be_empty }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
describe '#short_sha' do
|
2016-06-16 23:09:34 +05:30
|
|
|
subject { pipeline.short_sha }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build_stubbed(:ci_empty_pipeline, :created) }
|
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
it 'has 8 items' do
|
|
|
|
expect(subject.size).to eq(8)
|
|
|
|
end
|
|
|
|
it { expect(pipeline.sha).to start_with(subject) }
|
|
|
|
end
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
describe '#retried' do
|
2016-06-16 23:09:34 +05:30
|
|
|
subject { pipeline.retried }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created, project: project) }
|
|
|
|
let!(:build1) { create(:ci_build, pipeline: pipeline, name: 'deploy', retried: true) }
|
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, pipeline: pipeline, name: 'deploy')
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns old builds' do
|
2021-04-17 20:07:23 +05:30
|
|
|
is_expected.to contain_exactly(build1)
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-01-29 00:20:46 +05:30
|
|
|
describe '#coverage' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be_with_reload(:pipeline) { create(:ci_empty_pipeline) }
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
context 'with multiple pipelines' do
|
|
|
|
before_all do
|
|
|
|
create(:ci_build, name: "rspec", coverage: 30, pipeline: pipeline)
|
|
|
|
create(:ci_build, name: "rubocop", coverage: 40, pipeline: pipeline)
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it "calculates average when there are two builds with coverage" do
|
|
|
|
expect(pipeline.coverage).to eq("35.00")
|
|
|
|
end
|
|
|
|
|
|
|
|
it "calculates average when there are two builds with coverage and one with nil" do
|
|
|
|
create(:ci_build, pipeline: pipeline)
|
|
|
|
|
|
|
|
expect(pipeline.coverage).to eq("35.00")
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it "calculates average when there are two builds with coverage and one is retried" do
|
|
|
|
create(:ci_build, name: "rubocop", coverage: 30, pipeline: pipeline, retried: true)
|
|
|
|
|
|
|
|
expect(pipeline.coverage).to eq("35.00")
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
context 'when there is one build without coverage' do
|
|
|
|
it "calculates average to nil" do
|
|
|
|
create(:ci_build, pipeline: pipeline)
|
|
|
|
|
|
|
|
expect(pipeline.coverage).to be_nil
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#retryable?' do
|
|
|
|
subject { pipeline.retryable? }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created, project: project) }
|
|
|
|
|
2016-06-16 23:09:34 +05:30
|
|
|
context 'no failed builds' do
|
|
|
|
before do
|
2016-11-03 12:29:30 +05:30
|
|
|
create_build('rspec', 'success')
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2016-11-03 12:29:30 +05:30
|
|
|
it 'is not retryable' do
|
2016-06-16 23:09:34 +05:30
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
2016-11-03 12:29:30 +05:30
|
|
|
|
|
|
|
context 'one canceled job' do
|
|
|
|
before do
|
|
|
|
create_build('rubocop', 'canceled')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is retryable' do
|
|
|
|
is_expected.to be_truthy
|
|
|
|
end
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'with failed builds' do
|
|
|
|
before do
|
2016-11-03 12:29:30 +05:30
|
|
|
create_build('rspec', 'running')
|
|
|
|
create_build('rubocop', 'failed')
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2016-11-03 12:29:30 +05:30
|
|
|
it 'is retryable' do
|
2016-06-16 23:09:34 +05:30
|
|
|
is_expected.to be_truthy
|
|
|
|
end
|
|
|
|
end
|
2016-11-03 12:29:30 +05:30
|
|
|
|
|
|
|
def create_build(name, status)
|
|
|
|
create(:ci_build, name: name, status: status, pipeline: pipeline)
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2018-11-08 19:23:39 +05:30
|
|
|
describe '#persisted_variables' do
|
|
|
|
context 'when pipeline is not persisted yet' do
|
|
|
|
subject { build(:ci_pipeline).persisted_variables }
|
|
|
|
|
|
|
|
it 'does not contain some variables' do
|
|
|
|
keys = subject.map { |variable| variable[:key] }
|
|
|
|
|
|
|
|
expect(keys).not_to include 'CI_PIPELINE_ID'
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is persisted' do
|
|
|
|
subject { build_stubbed(:ci_pipeline).persisted_variables }
|
|
|
|
|
|
|
|
it 'does contains persisted variables' do
|
|
|
|
keys = subject.map { |variable| variable[:key] }
|
|
|
|
|
|
|
|
expect(keys).to eq %w[CI_PIPELINE_ID CI_PIPELINE_URL]
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-03-17 18:26:18 +05:30
|
|
|
describe '#predefined_variables' do
|
|
|
|
subject { pipeline.predefined_variables }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
it 'includes all predefined variables in a valid order' do
|
|
|
|
keys = subject.map { |variable| variable[:key] }
|
2018-03-17 18:26:18 +05:30
|
|
|
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(keys).to eq %w[
|
|
|
|
CI_PIPELINE_IID
|
|
|
|
CI_PIPELINE_SOURCE
|
2021-04-17 20:07:23 +05:30
|
|
|
CI_PIPELINE_CREATED_AT
|
2020-01-01 13:55:28 +05:30
|
|
|
CI_COMMIT_SHA
|
|
|
|
CI_COMMIT_SHORT_SHA
|
|
|
|
CI_COMMIT_BEFORE_SHA
|
|
|
|
CI_COMMIT_REF_NAME
|
|
|
|
CI_COMMIT_REF_SLUG
|
|
|
|
CI_COMMIT_BRANCH
|
|
|
|
CI_COMMIT_MESSAGE
|
|
|
|
CI_COMMIT_TITLE
|
|
|
|
CI_COMMIT_DESCRIPTION
|
|
|
|
CI_COMMIT_REF_PROTECTED
|
2020-11-24 15:15:51 +05:30
|
|
|
CI_COMMIT_TIMESTAMP
|
2020-01-01 13:55:28 +05:30
|
|
|
CI_BUILD_REF
|
|
|
|
CI_BUILD_BEFORE_SHA
|
|
|
|
CI_BUILD_REF_NAME
|
|
|
|
CI_BUILD_REF_SLUG
|
|
|
|
]
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
2019-02-15 15:39:39 +05:30
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'when merge request is present' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:assignees) { create_list(:user, 2) }
|
|
|
|
let_it_be(:milestone) { create(:milestone, project: project) }
|
|
|
|
let_it_be(:labels) { create_list(:label, 2) }
|
2019-02-15 15:39:39 +05:30
|
|
|
let(:merge_request) do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:merge_request, :simple,
|
2019-02-15 15:39:39 +05:30
|
|
|
source_project: project,
|
|
|
|
target_project: project,
|
2019-07-31 22:56:46 +05:30
|
|
|
assignees: assignees,
|
2019-07-07 11:18:12 +05:30
|
|
|
milestone: milestone,
|
|
|
|
labels: labels)
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'when pipeline for merge request is created' do
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline, :detached_merge_request_pipeline,
|
|
|
|
ci_ref_presence: false,
|
|
|
|
user: user,
|
|
|
|
merge_request: merge_request)
|
|
|
|
end
|
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
before do
|
2021-02-22 17:27:13 +05:30
|
|
|
project.add_developer(user)
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'exposes merge request pipeline variables' do
|
|
|
|
expect(subject.to_hash)
|
|
|
|
.to include(
|
|
|
|
'CI_MERGE_REQUEST_ID' => merge_request.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_IID' => merge_request.iid.to_s,
|
|
|
|
'CI_MERGE_REQUEST_REF_PATH' => merge_request.ref_path.to_s,
|
|
|
|
'CI_MERGE_REQUEST_PROJECT_ID' => merge_request.project.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_PROJECT_PATH' => merge_request.project.full_path,
|
|
|
|
'CI_MERGE_REQUEST_PROJECT_URL' => merge_request.project.web_url,
|
|
|
|
'CI_MERGE_REQUEST_TARGET_BRANCH_NAME' => merge_request.target_branch.to_s,
|
|
|
|
'CI_MERGE_REQUEST_TARGET_BRANCH_SHA' => '',
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_PROJECT_ID' => merge_request.source_project.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_PROJECT_PATH' => merge_request.source_project.full_path,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_PROJECT_URL' => merge_request.source_project.web_url,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_BRANCH_NAME' => merge_request.source_branch.to_s,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_BRANCH_SHA' => '',
|
|
|
|
'CI_MERGE_REQUEST_TITLE' => merge_request.title,
|
|
|
|
'CI_MERGE_REQUEST_ASSIGNEES' => merge_request.assignee_username_list,
|
|
|
|
'CI_MERGE_REQUEST_MILESTONE' => milestone.title,
|
|
|
|
'CI_MERGE_REQUEST_LABELS' => labels.map(&:title).sort.join(','),
|
|
|
|
'CI_MERGE_REQUEST_EVENT_TYPE' => 'detached',
|
|
|
|
'CI_OPEN_MERGE_REQUESTS' => merge_request.to_reference(full: true))
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'exposes diff variables' do
|
|
|
|
expect(subject.to_hash)
|
|
|
|
.to include(
|
|
|
|
'CI_MERGE_REQUEST_DIFF_ID' => merge_request.merge_request_diff.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_DIFF_BASE_SHA' => merge_request.merge_request_diff.base_commit_sha)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'without assignee' do
|
|
|
|
let(:assignees) { [] }
|
|
|
|
|
|
|
|
it 'does not expose assignee variable' do
|
|
|
|
expect(subject.to_hash.keys).not_to include('CI_MERGE_REQUEST_ASSIGNEES')
|
|
|
|
end
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
2019-07-07 11:18:12 +05:30
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'without milestone' do
|
|
|
|
let(:milestone) { nil }
|
2019-07-07 11:18:12 +05:30
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'does not expose milestone variable' do
|
|
|
|
expect(subject.to_hash.keys).not_to include('CI_MERGE_REQUEST_MILESTONE')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'without labels' do
|
|
|
|
let(:labels) { [] }
|
|
|
|
|
|
|
|
it 'does not expose labels variable' do
|
|
|
|
expect(subject.to_hash.keys).not_to include('CI_MERGE_REQUEST_LABELS')
|
|
|
|
end
|
2019-07-07 11:18:12 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'when pipeline on branch is created' do
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline, project: project, user: user, ref: 'feature')
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when a merge request is created' do
|
|
|
|
before do
|
|
|
|
merge_request
|
|
|
|
end
|
2019-07-07 11:18:12 +05:30
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'when user has access to project' do
|
|
|
|
before do
|
|
|
|
project.add_developer(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'merge request references are returned matching the pipeline' do
|
|
|
|
expect(subject.to_hash).to include(
|
|
|
|
'CI_OPEN_MERGE_REQUESTS' => merge_request.to_reference(full: true))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when user does not have access to project' do
|
|
|
|
it 'CI_OPEN_MERGE_REQUESTS is not returned' do
|
|
|
|
expect(subject.to_hash).not_to have_key('CI_OPEN_MERGE_REQUESTS')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when no a merge request is created' do
|
|
|
|
it 'CI_OPEN_MERGE_REQUESTS is not returned' do
|
|
|
|
expect(subject.to_hash).not_to have_key('CI_OPEN_MERGE_REQUESTS')
|
|
|
|
end
|
2019-07-07 11:18:12 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'with merged results' do
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline, :merged_result_pipeline, merge_request: merge_request)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'exposes merge request pipeline variables' do
|
|
|
|
expect(subject.to_hash)
|
|
|
|
.to include(
|
|
|
|
'CI_MERGE_REQUEST_ID' => merge_request.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_IID' => merge_request.iid.to_s,
|
|
|
|
'CI_MERGE_REQUEST_REF_PATH' => merge_request.ref_path.to_s,
|
|
|
|
'CI_MERGE_REQUEST_PROJECT_ID' => merge_request.project.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_PROJECT_PATH' => merge_request.project.full_path,
|
|
|
|
'CI_MERGE_REQUEST_PROJECT_URL' => merge_request.project.web_url,
|
|
|
|
'CI_MERGE_REQUEST_TARGET_BRANCH_NAME' => merge_request.target_branch.to_s,
|
|
|
|
'CI_MERGE_REQUEST_TARGET_BRANCH_SHA' => merge_request.target_branch_sha,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_PROJECT_ID' => merge_request.source_project.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_PROJECT_PATH' => merge_request.source_project.full_path,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_PROJECT_URL' => merge_request.source_project.web_url,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_BRANCH_NAME' => merge_request.source_branch.to_s,
|
|
|
|
'CI_MERGE_REQUEST_SOURCE_BRANCH_SHA' => merge_request.source_branch_sha,
|
|
|
|
'CI_MERGE_REQUEST_TITLE' => merge_request.title,
|
|
|
|
'CI_MERGE_REQUEST_ASSIGNEES' => merge_request.assignee_username_list,
|
|
|
|
'CI_MERGE_REQUEST_MILESTONE' => milestone.title,
|
|
|
|
'CI_MERGE_REQUEST_LABELS' => labels.map(&:title).sort.join(','),
|
|
|
|
'CI_MERGE_REQUEST_EVENT_TYPE' => 'merged_result')
|
|
|
|
end
|
2019-07-07 11:18:12 +05:30
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'exposes diff variables' do
|
|
|
|
expect(subject.to_hash)
|
|
|
|
.to include(
|
|
|
|
'CI_MERGE_REQUEST_DIFF_ID' => merge_request.merge_request_diff.id.to_s,
|
|
|
|
'CI_MERGE_REQUEST_DIFF_BASE_SHA' => merge_request.merge_request_diff.base_commit_sha)
|
2019-07-07 11:18:12 +05:30
|
|
|
end
|
|
|
|
end
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
2019-12-04 20:38:33 +05:30
|
|
|
|
|
|
|
context 'when source is external pull request' do
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline, source: :external_pull_request_event, external_pull_request: pull_request)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:pull_request) { create(:external_pull_request, project: project) }
|
|
|
|
|
|
|
|
it 'exposes external pull request pipeline variables' do
|
|
|
|
expect(subject.to_hash)
|
|
|
|
.to include(
|
|
|
|
'CI_EXTERNAL_PULL_REQUEST_IID' => pull_request.pull_request_iid.to_s,
|
2020-10-24 23:57:45 +05:30
|
|
|
'CI_EXTERNAL_PULL_REQUEST_SOURCE_REPOSITORY' => pull_request.source_repository,
|
|
|
|
'CI_EXTERNAL_PULL_REQUEST_TARGET_REPOSITORY' => pull_request.target_repository,
|
2019-12-04 20:38:33 +05:30
|
|
|
'CI_EXTERNAL_PULL_REQUEST_SOURCE_BRANCH_SHA' => pull_request.source_sha,
|
|
|
|
'CI_EXTERNAL_PULL_REQUEST_TARGET_BRANCH_SHA' => pull_request.target_sha,
|
|
|
|
'CI_EXTERNAL_PULL_REQUEST_SOURCE_BRANCH_NAME' => pull_request.source_branch,
|
|
|
|
'CI_EXTERNAL_PULL_REQUEST_TARGET_BRANCH_NAME' => pull_request.target_branch
|
|
|
|
)
|
|
|
|
end
|
|
|
|
end
|
2020-05-24 23:13:21 +05:30
|
|
|
|
|
|
|
describe 'variable CI_KUBERNETES_ACTIVE' do
|
|
|
|
context 'when pipeline.has_kubernetes_active? is true' do
|
|
|
|
before do
|
|
|
|
allow(pipeline).to receive(:has_kubernetes_active?).and_return(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is included with value 'true'" do
|
|
|
|
expect(subject.to_hash).to include('CI_KUBERNETES_ACTIVE' => 'true')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline.has_kubernetes_active? is false' do
|
|
|
|
before do
|
|
|
|
allow(pipeline).to receive(:has_kubernetes_active?).and_return(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not included' do
|
|
|
|
expect(subject.to_hash).not_to have_key('CI_KUBERNETES_ACTIVE')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
describe '#protected_ref?' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
2019-01-03 12:48:30 +05:30
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
it 'delegates method to project' do
|
|
|
|
expect(pipeline).not_to be_protected_ref
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#legacy_trigger' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:trigger_request) { build(:ci_trigger_request) }
|
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created, trigger_requests: [trigger_request]) }
|
2018-05-09 12:01:36 +05:30
|
|
|
|
|
|
|
it 'returns first trigger request' do
|
|
|
|
expect(pipeline.legacy_trigger).to eq trigger_request
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
describe '#auto_canceled?' do
|
|
|
|
subject { pipeline.auto_canceled? }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
context 'when it is canceled' do
|
|
|
|
before do
|
|
|
|
pipeline.cancel
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when there is auto_canceled_by' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
pipeline.auto_canceled_by = create(:ci_empty_pipeline)
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'is auto canceled' do
|
|
|
|
is_expected.to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when there is no auto_canceled_by' do
|
|
|
|
it 'is not auto canceled' do
|
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when it is retried and canceled manually' do
|
|
|
|
before do
|
|
|
|
pipeline.enqueue
|
|
|
|
pipeline.cancel
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not auto canceled' do
|
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
describe 'pipeline stages' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
describe 'legacy stages' do
|
2017-08-17 22:00:37 +05:30
|
|
|
before do
|
2018-05-09 12:01:36 +05:30
|
|
|
create(:commit_status, pipeline: pipeline,
|
|
|
|
stage: 'build',
|
|
|
|
name: 'linux',
|
|
|
|
stage_idx: 0,
|
|
|
|
status: 'success')
|
|
|
|
|
|
|
|
create(:commit_status, pipeline: pipeline,
|
|
|
|
stage: 'build',
|
|
|
|
name: 'mac',
|
|
|
|
stage_idx: 0,
|
|
|
|
status: 'failed')
|
|
|
|
|
|
|
|
create(:commit_status, pipeline: pipeline,
|
|
|
|
stage: 'deploy',
|
|
|
|
name: 'staging',
|
|
|
|
stage_idx: 2,
|
|
|
|
status: 'running')
|
|
|
|
|
|
|
|
create(:commit_status, pipeline: pipeline,
|
|
|
|
stage: 'test',
|
|
|
|
name: 'rspec',
|
|
|
|
stage_idx: 1,
|
|
|
|
status: 'success')
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#legacy_stages' do
|
2019-12-21 20:55:43 +05:30
|
|
|
using RSpec::Parameterized::TableSyntax
|
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
subject { pipeline.legacy_stages }
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
context 'stages list' do
|
|
|
|
it 'returns ordered list of stages' do
|
|
|
|
expect(subject.map(&:name)).to eq(%w[build test deploy])
|
|
|
|
end
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
context 'stages with statuses' do
|
|
|
|
let(:statuses) do
|
|
|
|
subject.map { |stage| [stage.name, stage.status] }
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
it 'returns list of stages with correct statuses' do
|
|
|
|
expect(statuses).to eq([%w(build failed),
|
|
|
|
%w(test success),
|
|
|
|
%w(deploy running)])
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
context 'when commit status is retried' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:old_commit_status) do
|
2020-10-24 23:57:45 +05:30
|
|
|
create(:commit_status, pipeline: pipeline,
|
2021-04-17 20:07:23 +05:30
|
|
|
stage: 'build',
|
|
|
|
name: 'mac',
|
|
|
|
stage_idx: 0,
|
|
|
|
status: 'success')
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
context 'when FF ci_remove_update_retried_from_process_pipeline is disabled' do
|
|
|
|
before do
|
|
|
|
stub_feature_flags(ci_remove_update_retried_from_process_pipeline: false)
|
|
|
|
|
|
|
|
Ci::ProcessPipelineService
|
|
|
|
.new(pipeline)
|
|
|
|
.execute
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'ignores the previous state' do
|
|
|
|
expect(statuses).to eq([%w(build success),
|
|
|
|
%w(test success),
|
|
|
|
%w(deploy running)])
|
|
|
|
end
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
|
|
|
end
|
2020-10-24 23:57:45 +05:30
|
|
|
end
|
2018-05-09 12:01:36 +05:30
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
context 'when there is a stage with warnings' do
|
|
|
|
before do
|
|
|
|
create(:commit_status, pipeline: pipeline,
|
|
|
|
stage: 'deploy',
|
|
|
|
name: 'prod:2',
|
|
|
|
stage_idx: 2,
|
|
|
|
status: 'failed',
|
|
|
|
allow_failure: true)
|
|
|
|
end
|
2018-05-09 12:01:36 +05:30
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
it 'populates stage with correct number of warnings' do
|
|
|
|
deploy_stage = pipeline.legacy_stages.third
|
2019-12-21 20:55:43 +05:30
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
expect(deploy_stage).not_to receive(:statuses)
|
|
|
|
expect(deploy_stage).to have_warnings
|
2018-05-09 12:01:36 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#stages_count' do
|
|
|
|
it 'returns a valid number of stages' do
|
|
|
|
expect(pipeline.stages_count).to eq(3)
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
describe '#stages_names' do
|
|
|
|
it 'returns a valid names of stages' do
|
|
|
|
expect(pipeline.stages_names).to eq(%w(build test deploy))
|
|
|
|
end
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
describe '#legacy_stage' do
|
|
|
|
subject { pipeline.legacy_stage('test') }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
context 'with status in stage' do
|
|
|
|
before do
|
|
|
|
create(:commit_status, pipeline: pipeline, stage: 'test')
|
|
|
|
end
|
|
|
|
|
|
|
|
it { expect(subject).to be_a Ci::LegacyStage }
|
|
|
|
it { expect(subject.name).to eq 'test' }
|
|
|
|
it { expect(subject.statuses).not_to be_empty }
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2018-05-09 12:01:36 +05:30
|
|
|
context 'without status in stage' do
|
|
|
|
before do
|
|
|
|
create(:commit_status, pipeline: pipeline, stage: 'build')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'return stage object' do
|
|
|
|
is_expected.to be_nil
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
2018-11-08 19:23:39 +05:30
|
|
|
|
|
|
|
describe '#stages' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-11-08 19:23:39 +05:30
|
|
|
before do
|
|
|
|
create(:ci_stage_entity, project: project,
|
|
|
|
pipeline: pipeline,
|
|
|
|
position: 4,
|
|
|
|
name: 'deploy')
|
|
|
|
|
|
|
|
create(:ci_build, project: project,
|
|
|
|
pipeline: pipeline,
|
|
|
|
stage: 'test',
|
|
|
|
stage_idx: 3,
|
|
|
|
name: 'test')
|
|
|
|
|
|
|
|
create(:ci_build, project: project,
|
|
|
|
pipeline: pipeline,
|
|
|
|
stage: 'build',
|
|
|
|
stage_idx: 2,
|
|
|
|
name: 'build')
|
|
|
|
|
|
|
|
create(:ci_stage_entity, project: project,
|
|
|
|
pipeline: pipeline,
|
|
|
|
position: 1,
|
|
|
|
name: 'sanity')
|
|
|
|
|
|
|
|
create(:ci_stage_entity, project: project,
|
|
|
|
pipeline: pipeline,
|
|
|
|
position: 5,
|
|
|
|
name: 'cleanup')
|
|
|
|
end
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
subject { pipeline.stages }
|
2020-05-24 23:13:21 +05:30
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
context 'when pipelines is not complete' do
|
|
|
|
it 'returns stages in valid order' do
|
|
|
|
expect(subject).to all(be_a Ci::Stage)
|
|
|
|
expect(subject.map(&:name))
|
|
|
|
.to eq %w[sanity build test deploy cleanup]
|
2020-05-24 23:13:21 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
context 'when pipeline is complete' do
|
2018-11-08 19:23:39 +05:30
|
|
|
before do
|
2020-10-24 23:57:45 +05:30
|
|
|
pipeline.succeed!
|
2018-11-08 19:23:39 +05:30
|
|
|
end
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
it 'returns stages in valid order' do
|
|
|
|
expect(subject).to all(be_a Ci::Stage)
|
|
|
|
expect(subject.map(&:name))
|
|
|
|
.to eq %w[sanity build test deploy cleanup]
|
2018-11-08 19:23:39 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
describe 'state machine' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be_with_reload(:pipeline) { create(:ci_empty_pipeline, :created) }
|
2020-06-23 00:09:42 +05:30
|
|
|
let(:current) { Time.current.change(usec: 0) }
|
2017-08-17 22:00:37 +05:30
|
|
|
let(:build) { create_build('build1', queued_at: 0) }
|
|
|
|
let(:build_b) { create_build('build2', queued_at: 0) }
|
|
|
|
let(:build_c) { create_build('build3', queued_at: 0) }
|
2016-09-13 17:45:13 +05:30
|
|
|
|
2019-12-21 20:55:43 +05:30
|
|
|
%w[succeed! drop! cancel! skip!].each do |action|
|
|
|
|
context "when the pipeline recieved #{action} event" do
|
|
|
|
it 'deletes a persistent ref' do
|
|
|
|
expect(pipeline.persistent_ref).to receive(:delete).once
|
|
|
|
|
|
|
|
pipeline.public_send(action)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
describe 'synching status to Jira' do
|
|
|
|
let(:worker) { ::JiraConnect::SyncBuildsWorker }
|
|
|
|
|
|
|
|
%i[prepare! run! skip! drop! succeed! cancel! block! delay!].each do |event|
|
|
|
|
context "when we call pipeline.#{event}" do
|
|
|
|
it 'triggers a Jira synch worker' do
|
|
|
|
expect(worker).to receive(:perform_async).with(pipeline.id, Integer)
|
|
|
|
|
|
|
|
pipeline.send(event)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
describe '#duration', :sidekiq_inline do
|
2017-08-17 22:00:37 +05:30
|
|
|
context 'when multiple builds are finished' do
|
|
|
|
before do
|
|
|
|
travel_to(current + 30) do
|
|
|
|
build.run!
|
2020-03-13 15:44:24 +05:30
|
|
|
build.reload.success!
|
2017-08-17 22:00:37 +05:30
|
|
|
build_b.run!
|
|
|
|
build_c.run!
|
|
|
|
end
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
travel_to(current + 40) do
|
2020-03-13 15:44:24 +05:30
|
|
|
build_b.reload.drop!
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
travel_to(current + 70) do
|
2020-03-13 15:44:24 +05:30
|
|
|
build_c.reload.success!
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
it 'matches sum of builds duration' do
|
|
|
|
pipeline.reload
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
expect(pipeline.duration).to eq(40)
|
2016-09-29 09:46:39 +05:30
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
context 'when pipeline becomes blocked' do
|
|
|
|
let!(:build) { create_build('build:1') }
|
|
|
|
let!(:action) { create_build('manual:action', :manual) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
travel_to(current + 1.minute) do
|
|
|
|
build.run!
|
|
|
|
end
|
|
|
|
|
|
|
|
travel_to(current + 5.minutes) do
|
2020-03-13 15:44:24 +05:30
|
|
|
build.reload.success!
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'recalculates pipeline duration' do
|
|
|
|
pipeline.reload
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
expect(pipeline).to be_manual
|
|
|
|
expect(pipeline.duration).to eq 4.minutes
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
describe '#started_at' do
|
2019-07-07 11:18:12 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, status: from_status) }
|
|
|
|
|
|
|
|
%i[created preparing pending].each do |status|
|
|
|
|
context "from #{status}" do
|
|
|
|
let(:from_status) { status }
|
|
|
|
|
|
|
|
it 'updates on transitioning to running' do
|
|
|
|
pipeline.run
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline.started_at).not_to be_nil
|
|
|
|
end
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
context 'from created' do
|
|
|
|
let(:from_status) { :created }
|
|
|
|
|
|
|
|
it 'does not update on transitioning to success' do
|
|
|
|
pipeline.succeed
|
2016-09-13 17:45:13 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline.started_at).to be_nil
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
describe '#finished_at' do
|
2019-12-26 22:10:19 +05:30
|
|
|
it 'updates on transitioning to success', :sidekiq_might_not_need_inline do
|
2016-09-13 17:45:13 +05:30
|
|
|
build.success
|
2016-06-16 23:09:34 +05:30
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
expect(pipeline.reload.finished_at).not_to be_nil
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
it 'does not update on transitioning to running' do
|
|
|
|
build.run
|
|
|
|
|
|
|
|
expect(pipeline.reload.finished_at).to be_nil
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2016-11-03 12:29:30 +05:30
|
|
|
describe 'merge request metrics' do
|
2019-07-07 11:18:12 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, status: from_status) }
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2016-11-03 12:29:30 +05:30
|
|
|
before do
|
|
|
|
expect(PipelineMetricsWorker).to receive(:perform_async).with(pipeline.id)
|
|
|
|
end
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2016-11-03 12:29:30 +05:30
|
|
|
context 'when transitioning to running' do
|
2019-07-07 11:18:12 +05:30
|
|
|
%i[created preparing pending].each do |status|
|
|
|
|
context "from #{status}" do
|
|
|
|
let(:from_status) { status }
|
|
|
|
|
|
|
|
it 'schedules metrics workers' do
|
|
|
|
pipeline.run
|
|
|
|
end
|
|
|
|
end
|
2016-09-29 09:46:39 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when transitioning to success' do
|
2019-07-07 11:18:12 +05:30
|
|
|
let(:from_status) { 'created' }
|
|
|
|
|
2016-11-03 12:29:30 +05:30
|
|
|
it 'schedules metrics workers' do
|
|
|
|
pipeline.succeed
|
2016-09-29 09:46:39 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
describe 'merge on success' do
|
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, status: from_status) }
|
|
|
|
|
|
|
|
%i[created preparing pending running].each do |status|
|
|
|
|
context "from #{status}" do
|
|
|
|
let(:from_status) { status }
|
|
|
|
|
2020-05-24 23:13:21 +05:30
|
|
|
it 'schedules daily build group report results worker' do
|
|
|
|
expect(Ci::DailyBuildGroupReportResultsWorker).to receive(:perform_in).with(10.minutes, pipeline.id)
|
2019-07-07 11:18:12 +05:30
|
|
|
|
|
|
|
pipeline.succeed
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
describe 'pipeline caching' do
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'performs ExpirePipelinesCacheWorker' do
|
|
|
|
expect(ExpirePipelineCacheWorker).to receive(:perform_async).with(pipeline.id)
|
2020-11-24 15:15:51 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
pipeline.cancel
|
2020-11-24 15:15:51 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#dangling?' do
|
|
|
|
it 'returns true if pipeline comes from any dangling sources' do
|
|
|
|
pipeline.source = Enums::Ci::Pipeline.dangling_sources.each_key.first
|
|
|
|
|
|
|
|
expect(pipeline).to be_dangling
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true if pipeline comes from any CI sources' do
|
|
|
|
pipeline.source = Enums::Ci::Pipeline.ci_sources.each_key.first
|
|
|
|
|
|
|
|
expect(pipeline).not_to be_dangling
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-09-04 21:01:54 +05:30
|
|
|
describe 'auto merge' do
|
2021-04-17 20:07:23 +05:30
|
|
|
context 'when auto merge is enabled' do
|
|
|
|
let_it_be_with_reload(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }
|
|
|
|
let_it_be_with_reload(:pipeline) do
|
|
|
|
create(:ci_pipeline, :running, project: merge_request.source_project,
|
|
|
|
ref: merge_request.source_branch,
|
|
|
|
sha: merge_request.diff_head_sha)
|
|
|
|
end
|
2019-09-04 21:01:54 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
before_all do
|
|
|
|
merge_request.update_head_pipeline
|
|
|
|
end
|
2019-09-04 21:01:54 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
%w[succeed! drop! cancel! skip!].each do |action|
|
|
|
|
context "when the pipeline recieved #{action} event" do
|
|
|
|
it 'performs AutoMergeProcessWorker' do
|
|
|
|
expect(AutoMergeProcessWorker).to receive(:perform_async).with(merge_request.id)
|
2019-09-04 21:01:54 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
pipeline.public_send(action)
|
|
|
|
end
|
2019-09-04 21:01:54 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when auto merge is not enabled in the merge request' do
|
|
|
|
let(:merge_request) { create(:merge_request) }
|
|
|
|
|
|
|
|
it 'performs AutoMergeProcessWorker' do
|
|
|
|
expect(AutoMergeProcessWorker).not_to receive(:perform_async)
|
|
|
|
|
|
|
|
pipeline.succeed!
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
describe 'auto devops pipeline metrics' do
|
|
|
|
using RSpec::Parameterized::TableSyntax
|
|
|
|
|
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, config_source: config_source) }
|
|
|
|
let(:config_source) { :auto_devops_source }
|
|
|
|
|
|
|
|
where(:action, :status) do
|
|
|
|
:succeed | 'success'
|
|
|
|
:drop | 'failed'
|
|
|
|
:skip | 'skipped'
|
|
|
|
:cancel | 'canceled'
|
|
|
|
end
|
|
|
|
|
|
|
|
with_them do
|
|
|
|
context "when pipeline receives action '#{params[:action]}'" do
|
|
|
|
subject { pipeline.public_send(action) }
|
|
|
|
|
|
|
|
it { expect { subject }.to change { auto_devops_pipelines_completed_total(status) }.by(1) }
|
|
|
|
|
|
|
|
context 'when not auto_devops_source?' do
|
|
|
|
let(:config_source) { :repository_source }
|
|
|
|
|
|
|
|
it { expect { subject }.not_to change { auto_devops_pipelines_completed_total(status) } }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
def auto_devops_pipelines_completed_total(status)
|
|
|
|
Gitlab::Metrics.counter(:auto_devops_pipelines_completed_total, 'Number of completed auto devops pipelines').get(status: status)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'bridge triggered pipeline' do
|
|
|
|
shared_examples 'upstream downstream pipeline' do
|
|
|
|
let!(:source_pipeline) { create(:ci_sources_pipeline, pipeline: downstream_pipeline, source_job: bridge) }
|
|
|
|
let!(:job) { downstream_pipeline.builds.first }
|
2020-03-13 15:44:24 +05:30
|
|
|
|
|
|
|
context 'when source bridge is dependent on pipeline status' do
|
2020-11-24 15:15:51 +05:30
|
|
|
let!(:bridge) { create(:ci_bridge, :strategy_depend, pipeline: upstream_pipeline) }
|
2020-03-13 15:44:24 +05:30
|
|
|
|
|
|
|
it 'schedules the pipeline bridge worker' do
|
2020-11-24 15:15:51 +05:30
|
|
|
expect(::Ci::PipelineBridgeStatusWorker).to receive(:perform_async).with(downstream_pipeline.id)
|
|
|
|
|
|
|
|
downstream_pipeline.succeed!
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the downstream pipeline first fails then retries and succeeds' do
|
|
|
|
it 'makes the upstream pipeline successful' do
|
|
|
|
Sidekiq::Testing.inline! { job.drop! }
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_failed
|
|
|
|
expect(upstream_pipeline.reload).to be_failed
|
|
|
|
|
|
|
|
Sidekiq::Testing.inline! do
|
|
|
|
new_job = Ci::Build.retry(job, project.users.first)
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_running
|
|
|
|
expect(upstream_pipeline.reload).to be_running
|
|
|
|
|
|
|
|
new_job.success!
|
|
|
|
end
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_success
|
|
|
|
expect(upstream_pipeline.reload).to be_success
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the downstream pipeline first succeeds then retries and fails' do
|
|
|
|
it 'makes the upstream pipeline failed' do
|
|
|
|
Sidekiq::Testing.inline! { job.success! }
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_success
|
|
|
|
expect(upstream_pipeline.reload).to be_success
|
|
|
|
|
|
|
|
Sidekiq::Testing.inline! do
|
|
|
|
new_job = Ci::Build.retry(job, project.users.first)
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_running
|
|
|
|
expect(upstream_pipeline.reload).to be_running
|
|
|
|
|
|
|
|
new_job.drop!
|
|
|
|
end
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_failed
|
|
|
|
expect(upstream_pipeline.reload).to be_failed
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the upstream pipeline has another dependent upstream pipeline' do
|
|
|
|
let!(:upstream_of_upstream_pipeline) { create(:ci_pipeline) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
upstream_bridge = create(:ci_bridge, :strategy_depend, pipeline: upstream_of_upstream_pipeline)
|
|
|
|
create(:ci_sources_pipeline, pipeline: upstream_pipeline,
|
|
|
|
source_job: upstream_bridge)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the downstream pipeline first fails then retries and succeeds' do
|
|
|
|
it 'makes upstream pipelines successful' do
|
|
|
|
Sidekiq::Testing.inline! { job.drop! }
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_failed
|
|
|
|
expect(upstream_pipeline.reload).to be_failed
|
|
|
|
expect(upstream_of_upstream_pipeline.reload).to be_failed
|
2020-03-13 15:44:24 +05:30
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
Sidekiq::Testing.inline! do
|
|
|
|
new_job = Ci::Build.retry(job, project.users.first)
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_running
|
|
|
|
expect(upstream_pipeline.reload).to be_running
|
|
|
|
expect(upstream_of_upstream_pipeline.reload).to be_running
|
|
|
|
|
|
|
|
new_job.success!
|
|
|
|
end
|
|
|
|
|
|
|
|
expect(downstream_pipeline.reload).to be_success
|
|
|
|
expect(upstream_pipeline.reload).to be_success
|
|
|
|
expect(upstream_of_upstream_pipeline.reload).to be_success
|
|
|
|
end
|
|
|
|
end
|
2020-03-13 15:44:24 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when source bridge is not dependent on pipeline status' do
|
2020-11-24 15:15:51 +05:30
|
|
|
let!(:bridge) { create(:ci_bridge, pipeline: upstream_pipeline) }
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
it 'does not schedule the pipeline bridge worker' do
|
|
|
|
expect(::Ci::PipelineBridgeStatusWorker).not_to receive(:perform_async)
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
downstream_pipeline.succeed!
|
2020-03-13 15:44:24 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
context 'multi-project pipelines' do
|
|
|
|
let!(:downstream_project) { create(:project, :repository) }
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:upstream_pipeline) { create(:ci_pipeline) }
|
2020-11-24 15:15:51 +05:30
|
|
|
let!(:downstream_pipeline) { create(:ci_pipeline, :with_job, project: downstream_project) }
|
|
|
|
|
|
|
|
it_behaves_like 'upstream downstream pipeline'
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'parent-child pipelines' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:upstream_pipeline) { create(:ci_pipeline) }
|
|
|
|
let!(:downstream_pipeline) { create(:ci_pipeline, :with_job) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it_behaves_like 'upstream downstream pipeline'
|
2020-03-13 15:44:24 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
def create_build(name, *traits, queued_at: current, started_from: 0, **opts)
|
|
|
|
create(:ci_build, *traits,
|
2016-09-29 09:46:39 +05:30
|
|
|
name: name,
|
|
|
|
pipeline: pipeline,
|
|
|
|
queued_at: queued_at,
|
2017-08-17 22:00:37 +05:30
|
|
|
started_at: queued_at + started_from,
|
|
|
|
**opts)
|
2016-09-29 09:46:39 +05:30
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
describe '#branch?' do
|
|
|
|
subject { pipeline.branch? }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, :created) }
|
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
context 'when ref is not a tag' do
|
2016-06-16 23:09:34 +05:30
|
|
|
before do
|
|
|
|
pipeline.tag = false
|
|
|
|
end
|
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
it 'return true' do
|
2016-06-16 23:09:34 +05:30
|
|
|
is_expected.to be_truthy
|
|
|
|
end
|
2019-02-15 15:39:39 +05:30
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
context 'when pipeline is merge request' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_pipeline, merge_request: merge_request) }
|
2019-02-15 15:39:39 +05:30
|
|
|
|
|
|
|
let(:merge_request) do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:merge_request, :simple,
|
2019-02-15 15:39:39 +05:30
|
|
|
source_project: project,
|
2021-04-17 20:07:23 +05:30
|
|
|
target_project: project)
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false' do
|
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
context 'when ref is a tag' do
|
2016-06-16 23:09:34 +05:30
|
|
|
before do
|
|
|
|
pipeline.tag = true
|
|
|
|
end
|
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
it 'return false' do
|
2016-06-16 23:09:34 +05:30
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2016-08-24 12:49:21 +05:30
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
describe '#git_ref' do
|
|
|
|
subject { pipeline.send(:git_ref) }
|
|
|
|
|
|
|
|
context 'when ref is branch' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, tag: false) }
|
|
|
|
|
|
|
|
it 'returns branch ref' do
|
|
|
|
is_expected.to eq(Gitlab::Git::BRANCH_REF_PREFIX + pipeline.ref.to_s)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when ref is tag' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, tag: true) }
|
|
|
|
|
|
|
|
it 'returns branch ref' do
|
|
|
|
is_expected.to eq(Gitlab::Git::TAG_REF_PREFIX + pipeline.ref.to_s)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when ref is merge request' do
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline,
|
2019-07-07 11:18:12 +05:30
|
|
|
source: :merge_request_event,
|
2019-02-15 15:39:39 +05:30
|
|
|
merge_request: merge_request)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:merge_request) do
|
|
|
|
create(:merge_request,
|
|
|
|
source_project: project,
|
|
|
|
source_branch: 'feature',
|
|
|
|
target_project: project,
|
|
|
|
target_branch: 'master')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns branch ref' do
|
|
|
|
is_expected.to eq(Gitlab::Git::BRANCH_REF_PREFIX + pipeline.ref.to_s)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-12-13 13:39:08 +05:30
|
|
|
describe 'ref_exists?' do
|
|
|
|
context 'when repository exists' do
|
|
|
|
using RSpec::Parameterized::TableSyntax
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline, refind: true) { create(:ci_empty_pipeline) }
|
|
|
|
|
2018-12-13 13:39:08 +05:30
|
|
|
where(:tag, :ref, :result) do
|
|
|
|
false | 'master' | true
|
|
|
|
false | 'non-existent-branch' | false
|
|
|
|
true | 'v1.1.0' | true
|
|
|
|
true | 'non-existent-tag' | false
|
|
|
|
end
|
|
|
|
|
|
|
|
with_them do
|
2021-04-17 20:07:23 +05:30
|
|
|
before do
|
|
|
|
pipeline.update!(tag: tag, ref: ref)
|
2018-12-13 13:39:08 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it "correctly detects ref" do
|
|
|
|
expect(pipeline.ref_exists?).to be result
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when repository does not exist' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_empty_pipeline, ref: 'master', project: build(:project)) }
|
2018-12-13 13:39:08 +05:30
|
|
|
|
|
|
|
it 'always returns false' do
|
|
|
|
expect(pipeline.ref_exists?).to eq false
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
context 'with non-empty project' do
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline,
|
|
|
|
ref: project.default_branch,
|
|
|
|
sha: project.commit.sha)
|
|
|
|
end
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '#lazy_ref_commit' do
|
|
|
|
let(:another) do
|
|
|
|
create(:ci_pipeline,
|
|
|
|
ref: 'feature',
|
|
|
|
sha: project.commit('feature').sha)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:unicode) do
|
|
|
|
create(:ci_pipeline,
|
|
|
|
ref: 'ü/unicode/multi-byte')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns the latest commit for a ref lazily' do
|
|
|
|
expect(project.repository)
|
|
|
|
.to receive(:list_commits_by_ref_name).once
|
|
|
|
.and_call_original
|
|
|
|
|
|
|
|
pipeline.lazy_ref_commit
|
|
|
|
another.lazy_ref_commit
|
|
|
|
unicode.lazy_ref_commit
|
|
|
|
|
|
|
|
expect(pipeline.lazy_ref_commit.id).to eq pipeline.sha
|
|
|
|
expect(another.lazy_ref_commit.id).to eq another.sha
|
|
|
|
expect(unicode.lazy_ref_commit).to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
describe '#latest?' do
|
|
|
|
context 'with latest sha' do
|
|
|
|
it 'returns true' do
|
|
|
|
expect(pipeline).to be_latest
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
context 'with a branch name as the ref' do
|
2020-07-28 23:09:34 +05:30
|
|
|
it 'looks up a commit for a branch' do
|
|
|
|
expect(pipeline.ref).to eq 'master'
|
|
|
|
expect(pipeline).to be_latest
|
|
|
|
end
|
|
|
|
end
|
2019-07-07 11:18:12 +05:30
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
context 'with a tag name as a ref' do
|
|
|
|
it 'looks up a commit for a tag' do
|
|
|
|
expect(project.repository.branch_names).not_to include 'v1.0.0'
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
pipeline.update!(sha: project.commit('v1.0.0').sha, ref: 'v1.0.0', tag: true)
|
2020-07-28 23:09:34 +05:30
|
|
|
|
|
|
|
expect(pipeline).to be_tag
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline).to be_latest
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
context 'with not latest sha' do
|
|
|
|
before do
|
2020-11-24 15:15:51 +05:30
|
|
|
pipeline.update!(sha: project.commit("#{project.default_branch}~1").sha)
|
2016-09-29 09:46:39 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false' do
|
|
|
|
expect(pipeline).not_to be_latest
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
describe '#manual_actions' do
|
|
|
|
subject { pipeline.manual_actions }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
it 'when none defined' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when action defined' do
|
|
|
|
let!(:manual) { create(:ci_build, :manual, pipeline: pipeline, name: 'deploy') }
|
|
|
|
|
|
|
|
it 'returns one action' do
|
|
|
|
is_expected.to contain_exactly(manual)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'there are multiple of the same name' do
|
|
|
|
let!(:manual2) { create(:ci_build, :manual, pipeline: pipeline, name: 'deploy') }
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
before do
|
2020-11-24 15:15:51 +05:30
|
|
|
manual.update!(retried: true)
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
it 'returns latest one' do
|
|
|
|
is_expected.to contain_exactly(manual2)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-12-05 23:21:45 +05:30
|
|
|
describe '#branch_updated?' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-12-05 23:21:45 +05:30
|
|
|
context 'when pipeline has before SHA' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
pipeline.update!(before_sha: 'a1b2c3d4')
|
2018-12-05 23:21:45 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'runs on a branch update push' do
|
|
|
|
expect(pipeline.before_sha).not_to be Gitlab::Git::BLANK_SHA
|
|
|
|
expect(pipeline.branch_updated?).to be true
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have before SHA' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
pipeline.update!(before_sha: Gitlab::Git::BLANK_SHA)
|
2018-12-05 23:21:45 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not run on a branch updating push' do
|
|
|
|
expect(pipeline.branch_updated?).to be false
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#modified_paths' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-12-05 23:21:45 +05:30
|
|
|
context 'when old and new revisions are set' do
|
|
|
|
before do
|
2020-11-24 15:15:51 +05:30
|
|
|
pipeline.update!(before_sha: '1234abcd', sha: '2345bcde')
|
2018-12-05 23:21:45 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'fetches stats for changes between commits' do
|
|
|
|
expect(project.repository)
|
|
|
|
.to receive(:diff_stats).with('1234abcd', '2345bcde')
|
|
|
|
.and_call_original
|
|
|
|
|
|
|
|
pipeline.modified_paths
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when either old or new revision is missing' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
pipeline.update!(before_sha: Gitlab::Git::BLANK_SHA)
|
2018-12-05 23:21:45 +05:30
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
it 'returns nil' do
|
|
|
|
expect(pipeline.modified_paths).to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when source is merge request' do
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline, source: :merge_request_event, merge_request: merge_request)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:merge_request) do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:merge_request, :simple,
|
2019-07-07 11:18:12 +05:30
|
|
|
source_project: project,
|
2021-04-17 20:07:23 +05:30
|
|
|
target_project: project)
|
2019-07-07 11:18:12 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns merge request modified paths' do
|
|
|
|
expect(pipeline.modified_paths).to match(merge_request.modified_paths)
|
2018-12-05 23:21:45 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-12-21 20:55:43 +05:30
|
|
|
describe '#all_worktree_paths' do
|
|
|
|
let(:files) { { 'main.go' => '', 'mocks/mocks.go' => '' } }
|
|
|
|
let(:project) { create(:project, :custom_repo, files: files) }
|
|
|
|
let(:pipeline) { build(:ci_pipeline, project: project, sha: project.repository.head_commit.sha) }
|
|
|
|
|
|
|
|
it 'returns all file paths cached' do
|
|
|
|
expect(project.repository).to receive(:ls_files).with(pipeline.sha).once.and_call_original
|
|
|
|
expect(pipeline.all_worktree_paths).to eq(files.keys)
|
|
|
|
expect(pipeline.all_worktree_paths).to eq(files.keys)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#top_level_worktree_paths' do
|
|
|
|
let(:files) { { 'main.go' => '', 'mocks/mocks.go' => '' } }
|
|
|
|
let(:project) { create(:project, :custom_repo, files: files) }
|
|
|
|
let(:pipeline) { build(:ci_pipeline, project: project, sha: project.repository.head_commit.sha) }
|
|
|
|
|
|
|
|
it 'returns top-level file paths cached' do
|
|
|
|
expect(project.repository).to receive(:tree).with(pipeline.sha).once.and_call_original
|
|
|
|
expect(pipeline.top_level_worktree_paths).to eq(['main.go'])
|
|
|
|
expect(pipeline.top_level_worktree_paths).to eq(['main.go'])
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-03-17 18:26:18 +05:30
|
|
|
describe '#has_kubernetes_active?' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created, project: project) }
|
|
|
|
|
2018-03-17 18:26:18 +05:30
|
|
|
context 'when kubernetes is active' do
|
|
|
|
context 'when user configured kubernetes from CI/CD > Clusters' do
|
|
|
|
let!(:cluster) { create(:cluster, :project, :provided_by_gcp) }
|
|
|
|
let(:project) { cluster.project }
|
|
|
|
|
2019-09-04 21:01:54 +05:30
|
|
|
it 'returns true' do
|
|
|
|
expect(pipeline).to have_kubernetes_active
|
|
|
|
end
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when kubernetes is not active' do
|
|
|
|
it 'returns false' do
|
|
|
|
expect(pipeline).not_to have_kubernetes_active
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
describe '#has_warnings?' do
|
|
|
|
subject { pipeline.has_warnings? }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
context 'build which is allowed to fail fails' do
|
|
|
|
before do
|
|
|
|
create :ci_build, :success, pipeline: pipeline, name: 'rspec'
|
|
|
|
create :ci_build, :allowed_to_fail, :failed, pipeline: pipeline, name: 'rubocop'
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
it 'returns true' do
|
|
|
|
is_expected.to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'build which is allowed to fail succeeds' do
|
|
|
|
before do
|
|
|
|
create :ci_build, :success, pipeline: pipeline, name: 'rspec'
|
|
|
|
create :ci_build, :allowed_to_fail, :success, pipeline: pipeline, name: 'rubocop'
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
|
2016-08-24 12:49:21 +05:30
|
|
|
it 'returns false' do
|
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'build is retried and succeeds' do
|
|
|
|
before do
|
|
|
|
create :ci_build, :success, pipeline: pipeline, name: 'rubocop'
|
|
|
|
create :ci_build, :failed, pipeline: pipeline, name: 'rspec'
|
|
|
|
create :ci_build, :success, pipeline: pipeline, name: 'rspec'
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false' do
|
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
|
|
|
end
|
2021-03-11 19:13:27 +05:30
|
|
|
|
|
|
|
context 'bridge which is allowed to fail fails' do
|
|
|
|
before do
|
|
|
|
create :ci_bridge, :allowed_to_fail, :failed, pipeline: pipeline, name: 'rubocop'
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true' do
|
|
|
|
is_expected.to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'bridge which is allowed to fail is successful' do
|
|
|
|
before do
|
|
|
|
create :ci_bridge, :allowed_to_fail, :success, pipeline: pipeline, name: 'rubocop'
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false' do
|
|
|
|
is_expected.to be_falsey
|
|
|
|
end
|
|
|
|
end
|
2016-08-24 12:49:21 +05:30
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
|
2018-11-08 19:23:39 +05:30
|
|
|
describe '#number_of_warnings' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2018-11-08 19:23:39 +05:30
|
|
|
it 'returns the number of warnings' do
|
|
|
|
create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline, name: 'rubocop')
|
2021-03-11 19:13:27 +05:30
|
|
|
create(:ci_bridge, :allowed_to_fail, :failed, pipeline: pipeline, name: 'rubocop')
|
2018-11-08 19:23:39 +05:30
|
|
|
|
2021-03-11 19:13:27 +05:30
|
|
|
expect(pipeline.number_of_warnings).to eq(2)
|
2018-11-08 19:23:39 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'supports eager loading of the number of warnings' do
|
2021-04-17 20:07:23 +05:30
|
|
|
pipeline2 = create(:ci_empty_pipeline, :created)
|
2018-11-08 19:23:39 +05:30
|
|
|
|
|
|
|
create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline, name: 'rubocop')
|
|
|
|
create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline2, name: 'rubocop')
|
|
|
|
|
2019-02-15 15:39:39 +05:30
|
|
|
pipelines = project.ci_pipelines.to_a
|
2018-11-08 19:23:39 +05:30
|
|
|
|
|
|
|
pipelines.each(&:number_of_warnings)
|
|
|
|
|
|
|
|
# To run the queries we need to actually use the lazy objects, which we do
|
|
|
|
# by just sending "to_i" to them.
|
|
|
|
amount = ActiveRecord::QueryRecorder
|
|
|
|
.new { pipelines.each { |p| p.number_of_warnings.to_i } }
|
|
|
|
.count
|
|
|
|
|
|
|
|
expect(amount).to eq(1)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
describe '#needs_processing?' do
|
|
|
|
using RSpec::Parameterized::TableSyntax
|
|
|
|
|
|
|
|
subject { pipeline.needs_processing? }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
where(:processed, :result) do
|
|
|
|
nil | true
|
|
|
|
false | true
|
|
|
|
true | false
|
|
|
|
end
|
|
|
|
|
|
|
|
with_them do
|
|
|
|
let(:build) do
|
|
|
|
create(:ci_build, :success, pipeline: pipeline, name: 'rubocop')
|
|
|
|
end
|
|
|
|
|
|
|
|
before do
|
|
|
|
build.update_column(:processed, processed)
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq(result) }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
context 'with outdated pipelines' do
|
|
|
|
before_all do
|
|
|
|
create_pipeline(:canceled, 'ref', 'A')
|
|
|
|
create_pipeline(:success, 'ref', 'A')
|
|
|
|
create_pipeline(:failed, 'ref', 'B')
|
|
|
|
create_pipeline(:skipped, 'feature', 'C')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
def create_pipeline(status, ref, sha)
|
2018-03-17 18:26:18 +05:30
|
|
|
create(
|
|
|
|
:ci_empty_pipeline,
|
|
|
|
status: status,
|
|
|
|
ref: ref,
|
2021-04-17 20:07:23 +05:30
|
|
|
sha: sha
|
2018-03-17 18:26:18 +05:30
|
|
|
)
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '.newest_first' do
|
|
|
|
it 'returns the pipelines from new to old' do
|
|
|
|
expect(described_class.newest_first.pluck(:status))
|
|
|
|
.to eq(%w[skipped failed success canceled])
|
|
|
|
end
|
2018-12-13 13:39:08 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'searches limited backlog' do
|
|
|
|
expect(described_class.newest_first(limit: 1).pluck(:status))
|
|
|
|
.to eq(%w[skipped])
|
|
|
|
end
|
2018-12-13 13:39:08 +05:30
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '.latest_status' do
|
|
|
|
context 'when no ref is specified' do
|
|
|
|
it 'returns the status of the latest pipeline' do
|
|
|
|
expect(described_class.latest_status).to eq('skipped')
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
context 'when ref is specified' do
|
|
|
|
it 'returns the status of the latest pipeline for the given ref' do
|
|
|
|
expect(described_class.latest_status('ref')).to eq('failed')
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '.latest_successful_for_ref' do
|
|
|
|
let!(:latest_successful_pipeline) do
|
|
|
|
create_pipeline(:success, 'ref', 'D')
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'returns the latest successful pipeline' do
|
|
|
|
expect(described_class.latest_successful_for_ref('ref'))
|
|
|
|
.to eq(latest_successful_pipeline)
|
|
|
|
end
|
2019-10-12 21:52:04 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '.latest_running_for_ref' do
|
|
|
|
let!(:latest_running_pipeline) do
|
|
|
|
create_pipeline(:running, 'ref', 'D')
|
|
|
|
end
|
2021-01-29 00:20:46 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'returns the latest running pipeline' do
|
|
|
|
expect(described_class.latest_running_for_ref('ref'))
|
|
|
|
.to eq(latest_running_pipeline)
|
|
|
|
end
|
2021-01-29 00:20:46 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '.latest_failed_for_ref' do
|
|
|
|
let!(:latest_failed_pipeline) do
|
|
|
|
create_pipeline(:failed, 'ref', 'D')
|
|
|
|
end
|
2021-01-29 00:20:46 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'returns the latest failed pipeline' do
|
|
|
|
expect(described_class.latest_failed_for_ref('ref'))
|
|
|
|
.to eq(latest_failed_pipeline)
|
|
|
|
end
|
2021-01-29 00:20:46 +05:30
|
|
|
end
|
2019-10-12 21:52:04 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '.latest_successful_for_sha' do
|
|
|
|
let!(:latest_successful_pipeline) do
|
|
|
|
create_pipeline(:success, 'ref', 'awesomesha')
|
|
|
|
end
|
2019-10-12 21:52:04 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'returns the latest successful pipeline' do
|
|
|
|
expect(described_class.latest_successful_for_sha('awesomesha'))
|
|
|
|
.to eq(latest_successful_pipeline)
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '.latest_successful_for_refs' do
|
|
|
|
let!(:latest_successful_pipeline1) do
|
|
|
|
create_pipeline(:success, 'ref1', 'D')
|
|
|
|
end
|
2018-03-17 18:26:18 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:latest_successful_pipeline2) do
|
|
|
|
create_pipeline(:success, 'ref2', 'D')
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
it 'returns the latest successful pipeline for both refs' do
|
|
|
|
refs = %w(ref1 ref2 ref3)
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
expect(described_class.latest_successful_for_refs(refs)).to eq({ 'ref1' => latest_successful_pipeline1, 'ref2' => latest_successful_pipeline2 })
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-12-21 20:55:43 +05:30
|
|
|
describe '.latest_pipeline_per_commit' do
|
|
|
|
let!(:commit_123_ref_master) do
|
|
|
|
create(
|
|
|
|
:ci_empty_pipeline,
|
|
|
|
status: 'success',
|
|
|
|
ref: 'master',
|
2021-04-17 20:07:23 +05:30
|
|
|
sha: '123'
|
2019-12-21 20:55:43 +05:30
|
|
|
)
|
|
|
|
end
|
2020-10-24 23:57:45 +05:30
|
|
|
|
2019-12-21 20:55:43 +05:30
|
|
|
let!(:commit_123_ref_develop) do
|
|
|
|
create(
|
|
|
|
:ci_empty_pipeline,
|
|
|
|
status: 'success',
|
|
|
|
ref: 'develop',
|
2021-04-17 20:07:23 +05:30
|
|
|
sha: '123'
|
2019-12-21 20:55:43 +05:30
|
|
|
)
|
|
|
|
end
|
2020-10-24 23:57:45 +05:30
|
|
|
|
2019-12-21 20:55:43 +05:30
|
|
|
let!(:commit_456_ref_test) do
|
|
|
|
create(
|
|
|
|
:ci_empty_pipeline,
|
|
|
|
status: 'success',
|
|
|
|
ref: 'test',
|
2021-04-17 20:07:23 +05:30
|
|
|
sha: '456'
|
2019-12-21 20:55:43 +05:30
|
|
|
)
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'without a ref' do
|
2019-12-21 20:55:43 +05:30
|
|
|
it 'returns a Hash containing the latest pipeline per commit for all refs' do
|
|
|
|
result = described_class.latest_pipeline_per_commit(%w[123 456])
|
|
|
|
|
|
|
|
expect(result).to match(
|
|
|
|
'123' => commit_123_ref_develop,
|
|
|
|
'456' => commit_456_ref_test
|
|
|
|
)
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
|
2019-12-21 20:55:43 +05:30
|
|
|
it 'only includes the latest pipeline of the given commit SHAs' do
|
|
|
|
result = described_class.latest_pipeline_per_commit(%w[123])
|
|
|
|
|
|
|
|
expect(result).to match(
|
|
|
|
'123' => commit_123_ref_develop
|
|
|
|
)
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'when there are two pipelines for a ref and SHA' do
|
2019-12-21 20:55:43 +05:30
|
|
|
let!(:commit_123_ref_master_latest) do
|
2018-03-17 18:26:18 +05:30
|
|
|
create(
|
|
|
|
:ci_empty_pipeline,
|
|
|
|
status: 'failed',
|
|
|
|
ref: 'master',
|
|
|
|
sha: '123',
|
|
|
|
project: project
|
|
|
|
)
|
2019-12-21 20:55:43 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns the latest pipeline' do
|
|
|
|
result = described_class.latest_pipeline_per_commit(%w[123])
|
2018-03-17 18:26:18 +05:30
|
|
|
|
2019-12-21 20:55:43 +05:30
|
|
|
expect(result).to match(
|
|
|
|
'123' => commit_123_ref_master_latest
|
|
|
|
)
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with a ref' do
|
|
|
|
it 'only includes the pipelines for the given ref' do
|
2019-12-21 20:55:43 +05:30
|
|
|
result = described_class.latest_pipeline_per_commit(%w[123 456], 'master')
|
|
|
|
|
|
|
|
expect(result).to match(
|
|
|
|
'123' => commit_123_ref_master
|
|
|
|
)
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-12-13 13:39:08 +05:30
|
|
|
describe '.latest_successful_ids_per_project' do
|
|
|
|
let(:projects) { create_list(:project, 2) }
|
|
|
|
let!(:pipeline1) { create(:ci_pipeline, :success, project: projects[0]) }
|
|
|
|
let!(:pipeline2) { create(:ci_pipeline, :success, project: projects[0]) }
|
|
|
|
let!(:pipeline3) { create(:ci_pipeline, :failed, project: projects[0]) }
|
|
|
|
let!(:pipeline4) { create(:ci_pipeline, :success, project: projects[1]) }
|
|
|
|
|
|
|
|
it 'returns expected pipeline ids' do
|
|
|
|
expect(described_class.latest_successful_ids_per_project)
|
|
|
|
.to contain_exactly(pipeline2, pipeline4)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '.last_finished_for_ref_id' do
|
|
|
|
let(:branch) { project.default_branch }
|
|
|
|
let(:ref) { project.ci_refs.take }
|
2020-11-24 15:15:51 +05:30
|
|
|
let(:dangling_source) { Enums::Ci::Pipeline.sources[:ondemand_dast_scan] }
|
2020-07-28 23:09:34 +05:30
|
|
|
let!(:pipeline1) { create(:ci_pipeline, :success, project: project, ref: branch) }
|
|
|
|
let!(:pipeline2) { create(:ci_pipeline, :success, project: project, ref: branch) }
|
|
|
|
let!(:pipeline3) { create(:ci_pipeline, :failed, project: project, ref: branch) }
|
|
|
|
let!(:pipeline4) { create(:ci_pipeline, :success, project: project, ref: branch) }
|
2020-11-24 15:15:51 +05:30
|
|
|
let!(:pipeline5) { create(:ci_pipeline, :success, project: project, ref: branch, source: dangling_source) }
|
2020-07-28 23:09:34 +05:30
|
|
|
|
|
|
|
it 'returns the expected pipeline' do
|
|
|
|
result = described_class.last_finished_for_ref_id(ref.id)
|
|
|
|
expect(result).to eq(pipeline4)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-09-10 17:25:29 +05:30
|
|
|
describe '.internal_sources' do
|
|
|
|
subject { described_class.internal_sources }
|
|
|
|
|
|
|
|
it { is_expected.to be_an(Array) }
|
|
|
|
end
|
|
|
|
|
2019-10-12 21:52:04 +05:30
|
|
|
describe '.bridgeable_statuses' do
|
|
|
|
subject { described_class.bridgeable_statuses }
|
|
|
|
|
|
|
|
it { is_expected.to be_an(Array) }
|
2020-03-13 15:44:24 +05:30
|
|
|
it { is_expected.not_to include('created', 'waiting_for_resource', 'preparing', 'pending') }
|
2019-10-12 21:52:04 +05:30
|
|
|
end
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
describe '#status', :sidekiq_inline do
|
2016-09-13 17:45:13 +05:30
|
|
|
subject { pipeline.reload.status }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
let(:build) { create(:ci_build, :created, pipeline: pipeline, name: 'test') }
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
context 'on waiting for resource' do
|
|
|
|
before do
|
2021-03-11 19:13:27 +05:30
|
|
|
allow(build).to receive(:with_resource_group?) { true }
|
2020-03-13 15:44:24 +05:30
|
|
|
allow(Ci::ResourceGroups::AssignResourceFromResourceGroupWorker).to receive(:perform_async)
|
|
|
|
|
|
|
|
build.enqueue
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq('waiting_for_resource') }
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
context 'on prepare' do
|
|
|
|
before do
|
|
|
|
# Prevent skipping directly to 'pending'
|
|
|
|
allow(build).to receive(:prerequisites).and_return([double])
|
|
|
|
allow(Ci::BuildPrepareWorker).to receive(:perform_async)
|
|
|
|
|
|
|
|
build.enqueue
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq('preparing') }
|
|
|
|
end
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
context 'on queuing' do
|
|
|
|
before do
|
|
|
|
build.enqueue
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq('pending') }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'on run' do
|
|
|
|
before do
|
|
|
|
build.enqueue
|
2020-03-13 15:44:24 +05:30
|
|
|
build.reload.run
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq('running') }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'on drop' do
|
|
|
|
before do
|
|
|
|
build.drop
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq('failed') }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'on success' do
|
|
|
|
before do
|
|
|
|
build.success
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq('success') }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'on cancel' do
|
|
|
|
before do
|
|
|
|
build.cancel
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
context 'when build is pending' do
|
|
|
|
let(:build) do
|
|
|
|
create(:ci_build, :pending, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq('canceled') }
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'on failure and build retry' do
|
|
|
|
before do
|
2017-09-10 17:25:29 +05:30
|
|
|
stub_not_protect_default_branch
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
build.drop
|
2017-08-17 22:00:37 +05:30
|
|
|
project.add_developer(user)
|
|
|
|
|
|
|
|
Ci::Build.retry(build, user)
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
# We are changing a state: created > failed > running
|
|
|
|
# Instead of: created > failed > pending
|
|
|
|
# Since the pipeline already run, so it should not be pending anymore
|
|
|
|
|
|
|
|
it { is_expected.to eq('running') }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
describe '#detailed_status' do
|
|
|
|
subject { pipeline.detailed_status(user) }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
context 'when pipeline is created' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :created) }
|
2017-08-17 22:00:37 +05:30
|
|
|
|
|
|
|
it 'returns detailed status for created pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatusText|created')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is pending' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :pending) }
|
|
|
|
|
|
|
|
it 'returns detailed status for pending pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatusText|pending')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is running' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :running) }
|
|
|
|
|
|
|
|
it 'returns detailed status for running pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatus|running')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is successful' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :success) }
|
|
|
|
|
|
|
|
it 'returns detailed status for successful pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatusText|passed')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is failed' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :failed) }
|
|
|
|
|
|
|
|
it 'returns detailed status for failed pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatusText|failed')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is canceled' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :canceled) }
|
|
|
|
|
|
|
|
it 'returns detailed status for canceled pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatusText|canceled')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is skipped' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :skipped) }
|
|
|
|
|
|
|
|
it 'returns detailed status for skipped pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatusText|skipped')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is blocked' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :manual) }
|
|
|
|
|
|
|
|
it 'returns detailed status for blocked pipeline' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.text).to eq s_('CiStatusText|blocked')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is successful but with warnings' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, status: :success) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'retruns detailed status for successful pipeline with warnings' do
|
2020-01-01 13:55:28 +05:30
|
|
|
expect(subject.label).to eq(s_('CiStatusLabel|passed with warnings'))
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#cancelable?' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
%i[created running pending].each do |status0|
|
|
|
|
context "when there is a build #{status0}" do
|
|
|
|
before do
|
|
|
|
create(:ci_build, status0, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is cancelable' do
|
|
|
|
expect(pipeline.cancelable?).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when there is an external job #{status0}" do
|
|
|
|
before do
|
|
|
|
create(:generic_commit_status, status0, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is cancelable' do
|
|
|
|
expect(pipeline.cancelable?).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
%i[success failed canceled].each do |status1|
|
|
|
|
context "when there are generic_commit_status jobs for #{status0} and #{status1}" do
|
|
|
|
before do
|
|
|
|
create(:generic_commit_status, status0, pipeline: pipeline)
|
|
|
|
create(:generic_commit_status, status1, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is cancelable' do
|
|
|
|
expect(pipeline.cancelable?).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when there are generic_commit_status and ci_build jobs for #{status0} and #{status1}" do
|
|
|
|
before do
|
|
|
|
create(:generic_commit_status, status0, pipeline: pipeline)
|
|
|
|
create(:ci_build, status1, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is cancelable' do
|
|
|
|
expect(pipeline.cancelable?).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when there are ci_build jobs for #{status0} and #{status1}" do
|
|
|
|
before do
|
|
|
|
create(:ci_build, status0, pipeline: pipeline)
|
|
|
|
create(:ci_build, status1, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is cancelable' do
|
|
|
|
expect(pipeline.cancelable?).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
%i[success failed canceled].each do |status|
|
|
|
|
context "when there is a build #{status}" do
|
|
|
|
before do
|
|
|
|
create(:ci_build, status, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not cancelable' do
|
|
|
|
expect(pipeline.cancelable?).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when there is an external job #{status}" do
|
|
|
|
before do
|
|
|
|
create(:generic_commit_status, status, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not cancelable' do
|
|
|
|
expect(pipeline.cancelable?).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2017-09-10 17:25:29 +05:30
|
|
|
|
|
|
|
context 'when there is a manual action present in the pipeline' do
|
|
|
|
before do
|
|
|
|
create(:ci_build, :manual, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not cancelable' do
|
|
|
|
expect(pipeline).not_to be_cancelable
|
|
|
|
end
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
describe '#cancel_running' do
|
2021-04-17 20:07:23 +05:30
|
|
|
subject(:latest_status) { pipeline.statuses.pluck(:status) }
|
|
|
|
|
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
2017-08-17 22:00:37 +05:30
|
|
|
|
|
|
|
context 'when there is a running external job and a regular job' do
|
|
|
|
before do
|
|
|
|
create(:ci_build, :running, pipeline: pipeline)
|
|
|
|
create(:generic_commit_status, :running, pipeline: pipeline)
|
|
|
|
|
|
|
|
pipeline.cancel_running
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'cancels both jobs' do
|
|
|
|
expect(latest_status).to contain_exactly('canceled', 'canceled')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when jobs are in different stages' do
|
|
|
|
before do
|
|
|
|
create(:ci_build, :running, stage_idx: 0, pipeline: pipeline)
|
|
|
|
create(:ci_build, :running, stage_idx: 1, pipeline: pipeline)
|
|
|
|
|
|
|
|
pipeline.cancel_running
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'cancels both jobs' do
|
|
|
|
expect(latest_status).to contain_exactly('canceled', 'canceled')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when there are created builds present in the pipeline' do
|
|
|
|
before do
|
|
|
|
create(:ci_build, :running, stage_idx: 0, pipeline: pipeline)
|
|
|
|
create(:ci_build, :created, stage_idx: 1, pipeline: pipeline)
|
|
|
|
|
|
|
|
pipeline.cancel_running
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'cancels created builds' do
|
|
|
|
expect(latest_status).to eq %w(canceled canceled)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#retry_failed' do
|
2021-04-17 20:07:23 +05:30
|
|
|
subject(:latest_status) { pipeline.latest_statuses.pluck(:status) }
|
|
|
|
|
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
2017-08-17 22:00:37 +05:30
|
|
|
|
|
|
|
before do
|
2017-09-10 17:25:29 +05:30
|
|
|
stub_not_protect_default_branch
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
project.add_developer(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when there is a failed build and failed external status' do
|
|
|
|
before do
|
|
|
|
create(:ci_build, :failed, name: 'build', pipeline: pipeline)
|
|
|
|
create(:generic_commit_status, :failed, name: 'jenkins', pipeline: pipeline)
|
|
|
|
|
|
|
|
pipeline.retry_failed(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'retries only build' do
|
|
|
|
expect(latest_status).to contain_exactly('pending', 'failed')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when builds are in different stages' do
|
|
|
|
before do
|
|
|
|
create(:ci_build, :failed, name: 'build', stage_idx: 0, pipeline: pipeline)
|
|
|
|
create(:ci_build, :failed, name: 'jenkins', stage_idx: 1, pipeline: pipeline)
|
|
|
|
|
|
|
|
pipeline.retry_failed(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'retries both builds' do
|
|
|
|
expect(latest_status).to contain_exactly('pending', 'created')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when there are canceled and failed' do
|
|
|
|
before do
|
|
|
|
create(:ci_build, :failed, name: 'build', stage_idx: 0, pipeline: pipeline)
|
|
|
|
create(:ci_build, :canceled, name: 'jenkins', stage_idx: 1, pipeline: pipeline)
|
|
|
|
|
|
|
|
pipeline.retry_failed(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'retries both builds' do
|
|
|
|
expect(latest_status).to contain_exactly('pending', 'created')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
describe '#execute_hooks' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
2016-09-29 09:46:39 +05:30
|
|
|
let!(:build_a) { create_build('a', 0) }
|
2018-03-17 18:26:18 +05:30
|
|
|
let!(:build_b) { create_build('b', 0) }
|
2016-09-13 17:45:13 +05:30
|
|
|
|
|
|
|
let!(:hook) do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:project_hook, pipeline_events: enabled)
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
before do
|
2017-09-10 17:25:29 +05:30
|
|
|
WebHookWorker.drain
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'with pipeline hooks enabled' do
|
|
|
|
let(:enabled) { true }
|
|
|
|
|
|
|
|
before do
|
2019-09-04 21:01:54 +05:30
|
|
|
stub_full_request(hook.url, method: :post)
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
context 'with multiple builds', :sidekiq_inline do
|
2016-09-13 17:45:13 +05:30
|
|
|
context 'when build is queued' do
|
|
|
|
before do
|
2020-03-13 15:44:24 +05:30
|
|
|
build_a.reload.enqueue
|
|
|
|
build_b.reload.enqueue
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
it 'receives a pending event once' do
|
2016-09-13 17:45:13 +05:30
|
|
|
expect(WebMock).to have_requested_pipeline_hook('pending').once
|
|
|
|
end
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
it 'builds hook data once' do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:pipelines_email_service)
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
expect(Gitlab::DataBuilder::Pipeline).to receive(:build).once.and_call_original
|
|
|
|
|
|
|
|
pipeline.execute_hooks
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'when build is run' do
|
|
|
|
before do
|
2020-03-13 15:44:24 +05:30
|
|
|
build_a.reload.enqueue
|
|
|
|
build_a.reload.run!
|
|
|
|
build_b.reload.enqueue
|
|
|
|
build_b.reload.run!
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
it 'receives a running event once' do
|
2016-09-13 17:45:13 +05:30
|
|
|
expect(WebMock).to have_requested_pipeline_hook('running').once
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when all builds succeed' do
|
|
|
|
before do
|
|
|
|
build_a.success
|
2017-08-17 22:00:37 +05:30
|
|
|
|
|
|
|
# We have to reload build_b as this is in next stage and it gets triggered by PipelineProcessWorker
|
|
|
|
build_b.reload.success
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
it 'receives a success event once' do
|
2016-09-13 17:45:13 +05:30
|
|
|
expect(WebMock).to have_requested_pipeline_hook('success').once
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
context 'when stage one failed' do
|
2018-03-17 18:26:18 +05:30
|
|
|
let!(:build_b) { create_build('b', 1) }
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
before do
|
|
|
|
build_a.drop
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'receives a failed event once' do
|
|
|
|
expect(WebMock).to have_requested_pipeline_hook('failed').once
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-13 17:45:13 +05:30
|
|
|
def have_requested_pipeline_hook(status)
|
2019-09-04 21:01:54 +05:30
|
|
|
have_requested(:post, stubbed_hostname(hook.url)).with do |req|
|
2020-05-24 23:13:21 +05:30
|
|
|
json_body = Gitlab::Json.parse(req.body)
|
2016-09-13 17:45:13 +05:30
|
|
|
json_body['object_attributes']['status'] == status &&
|
|
|
|
json_body['builds'].length == 2
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with pipeline hooks disabled' do
|
|
|
|
let(:enabled) { false }
|
|
|
|
|
|
|
|
before do
|
|
|
|
build_a.enqueue
|
|
|
|
build_b.enqueue
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'did not execute pipeline_hook after touched' do
|
|
|
|
expect(WebMock).not_to have_requested(:post, hook.url)
|
|
|
|
end
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
it 'does not build hook data' do
|
|
|
|
expect(Gitlab::DataBuilder::Pipeline).not_to receive(:build)
|
|
|
|
|
|
|
|
pipeline.execute_hooks
|
|
|
|
end
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
|
2016-09-29 09:46:39 +05:30
|
|
|
def create_build(name, stage_idx)
|
|
|
|
create(:ci_build,
|
|
|
|
:created,
|
|
|
|
pipeline: pipeline,
|
|
|
|
name: name,
|
2020-03-13 15:44:24 +05:30
|
|
|
stage: "stage:#{stage_idx}",
|
2016-09-29 09:46:39 +05:30
|
|
|
stage_idx: stage_idx)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
describe "#merge_requests_as_head_pipeline" do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be_with_reload(:pipeline) { create(:ci_empty_pipeline, status: 'created', ref: 'master', sha: 'a288a022a53a5a944fae87bcec6efc87b7061808') }
|
2016-09-29 09:46:39 +05:30
|
|
|
|
|
|
|
it "returns merge requests whose `diff_head_sha` matches the pipeline's SHA" do
|
2020-01-01 13:55:28 +05:30
|
|
|
allow_next_instance_of(MergeRequest) do |instance|
|
|
|
|
allow(instance).to receive(:diff_head_sha) { 'a288a022a53a5a944fae87bcec6efc87b7061808' }
|
|
|
|
end
|
2017-09-10 17:25:29 +05:30
|
|
|
merge_request = create(:merge_request, source_project: project, head_pipeline: pipeline, source_branch: pipeline.ref)
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline.merge_requests_as_head_pipeline).to eq([merge_request])
|
2016-09-29 09:46:39 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't return merge requests whose source branch doesn't match the pipeline's ref" do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:merge_request, :simple, source_project: project)
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline.merge_requests_as_head_pipeline).to be_empty
|
2016-09-29 09:46:39 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't return merge requests whose `diff_head_sha` doesn't match the pipeline's SHA" do
|
|
|
|
create(:merge_request, source_project: project, source_branch: pipeline.ref)
|
2020-01-01 13:55:28 +05:30
|
|
|
allow_next_instance_of(MergeRequest) do |instance|
|
|
|
|
allow(instance).to receive(:diff_head_sha) { '97de212e80737a608d939f648d959671fb0a0142b' }
|
|
|
|
end
|
2016-09-29 09:46:39 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline.merge_requests_as_head_pipeline).to be_empty
|
2016-09-13 17:45:13 +05:30
|
|
|
end
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2020-04-22 19:07:51 +05:30
|
|
|
describe '#all_merge_requests' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be_with_reload(:project) { create(:project) }
|
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created, project: project) }
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
shared_examples 'a method that returns all merge requests for a given pipeline' do
|
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, status: 'created', project: pipeline_project, ref: 'master') }
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2020-04-22 19:07:51 +05:30
|
|
|
it 'returns all merge requests having the same source branch and the pipeline sha' do
|
2019-07-07 11:18:12 +05:30
|
|
|
merge_request = create(:merge_request, source_project: pipeline_project, target_project: project, source_branch: pipeline.ref)
|
2019-05-30 16:15:17 +05:30
|
|
|
|
2020-04-22 19:07:51 +05:30
|
|
|
create(:merge_request_diff, merge_request: merge_request).tap do |diff|
|
|
|
|
create(:merge_request_diff_commit, merge_request_diff: diff, sha: pipeline.sha)
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline.all_merge_requests).to eq([merge_request])
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
2020-04-22 19:07:51 +05:30
|
|
|
it "doesn't return merge requests having the same source branch without the pipeline sha" do
|
|
|
|
merge_request = create(:merge_request, source_project: pipeline_project, target_project: project, source_branch: pipeline.ref)
|
|
|
|
create(:merge_request_diff, merge_request: merge_request).tap do |diff|
|
|
|
|
create(:merge_request_diff_commit, merge_request_diff: diff, sha: 'unrelated')
|
|
|
|
end
|
|
|
|
|
|
|
|
expect(pipeline.all_merge_requests).to be_empty
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
it "doesn't return merge requests having a different source branch" do
|
|
|
|
create(:merge_request, source_project: pipeline_project, target_project: project, source_branch: 'feature', target_branch: 'master')
|
2019-02-15 15:39:39 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
expect(pipeline.all_merge_requests).to be_empty
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
context 'when there is a merge request pipeline' do
|
|
|
|
let(:source_branch) { 'feature' }
|
|
|
|
let(:target_branch) { 'master' }
|
2019-02-15 15:39:39 +05:30
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
let!(:pipeline) do
|
2019-02-15 15:39:39 +05:30
|
|
|
create(:ci_pipeline,
|
2019-07-07 11:18:12 +05:30
|
|
|
source: :merge_request_event,
|
|
|
|
project: pipeline_project,
|
2019-02-15 15:39:39 +05:30
|
|
|
ref: source_branch,
|
2019-07-07 11:18:12 +05:30
|
|
|
merge_request: merge_request)
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
let(:merge_request) do
|
2019-02-15 15:39:39 +05:30
|
|
|
create(:merge_request,
|
2019-07-07 11:18:12 +05:30
|
|
|
source_project: pipeline_project,
|
2019-02-15 15:39:39 +05:30
|
|
|
source_branch: source_branch,
|
|
|
|
target_project: project,
|
2019-07-07 11:18:12 +05:30
|
|
|
target_branch: target_branch)
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
it 'returns an associated merge request' do
|
|
|
|
expect(pipeline.all_merge_requests).to eq([merge_request])
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
2019-07-07 11:18:12 +05:30
|
|
|
|
|
|
|
context 'when there is another merge request pipeline that targets a different branch' do
|
|
|
|
let(:target_branch_2) { 'merge-test' }
|
|
|
|
|
|
|
|
let!(:pipeline_2) do
|
|
|
|
create(:ci_pipeline,
|
|
|
|
source: :merge_request_event,
|
|
|
|
project: pipeline_project,
|
|
|
|
ref: source_branch,
|
|
|
|
merge_request: merge_request_2)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:merge_request_2) do
|
|
|
|
create(:merge_request,
|
|
|
|
source_project: pipeline_project,
|
|
|
|
source_branch: source_branch,
|
|
|
|
target_project: project,
|
|
|
|
target_branch: target_branch_2)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not return an associated merge request' do
|
|
|
|
expect(pipeline.all_merge_requests).not_to include(merge_request_2)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it_behaves_like 'a method that returns all merge requests for a given pipeline' do
|
|
|
|
let(:pipeline_project) { project }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'for a fork' do
|
|
|
|
let(:fork) { fork_project(project) }
|
|
|
|
|
|
|
|
it_behaves_like 'a method that returns all merge requests for a given pipeline' do
|
|
|
|
let(:pipeline_project) { fork }
|
2019-02-15 15:39:39 +05:30
|
|
|
end
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
describe '#related_merge_requests' do
|
|
|
|
let(:merge_request) { create(:merge_request, source_project: project, source_branch: 'feature', target_branch: 'master') }
|
|
|
|
let(:other_merge_request) { create(:merge_request, source_project: project, source_branch: 'feature', target_branch: 'stable') }
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:branch_pipeline) { create(:ci_pipeline, ref: 'feature') }
|
2021-02-22 17:27:13 +05:30
|
|
|
let(:merge_pipeline) { create(:ci_pipeline, :detached_merge_request_pipeline, merge_request: merge_request) }
|
|
|
|
|
|
|
|
context 'for a branch pipeline' do
|
|
|
|
subject { branch_pipeline.related_merge_requests }
|
|
|
|
|
|
|
|
it 'when no merge request is created' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'when another merge requests are created' do
|
|
|
|
merge_request
|
|
|
|
other_merge_request
|
|
|
|
|
|
|
|
is_expected.to contain_exactly(merge_request, other_merge_request)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'for a merge pipeline' do
|
|
|
|
subject { merge_pipeline.related_merge_requests }
|
|
|
|
|
|
|
|
it 'when only merge pipeline is created' do
|
|
|
|
merge_pipeline
|
|
|
|
|
|
|
|
is_expected.to contain_exactly(merge_request)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'when a merge request is created' do
|
|
|
|
merge_pipeline
|
|
|
|
other_merge_request
|
|
|
|
|
|
|
|
is_expected.to contain_exactly(merge_request, other_merge_request)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#open_merge_requests_refs' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:pipeline) { create(:ci_pipeline, user: user, ref: 'feature') }
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:merge_request) { create(:merge_request, source_project: project, source_branch: 'feature', target_branch: 'master') }
|
|
|
|
|
|
|
|
subject { pipeline.open_merge_requests_refs }
|
|
|
|
|
|
|
|
context 'when user is a developer' do
|
|
|
|
before do
|
|
|
|
project.add_developer(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns open merge requests' do
|
|
|
|
is_expected.to eq([merge_request.to_reference(full: true)])
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not return closed merge requests' do
|
|
|
|
merge_request.close!
|
|
|
|
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'limits amount of returned merge requests' do
|
|
|
|
let!(:other_merge_requests) do
|
|
|
|
Array.new(4) do |idx|
|
|
|
|
create(:merge_request, source_project: project, source_branch: 'feature', target_branch: "master-#{idx}")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:other_merge_requests_refs) do
|
|
|
|
other_merge_requests.map { |mr| mr.to_reference(full: true) }
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns only last 4 in a reverse order' do
|
|
|
|
is_expected.to eq(other_merge_requests_refs.reverse)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when user does not have permissions' do
|
|
|
|
it 'does not return any merge requests' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '#same_family_pipeline_ids' do
|
2020-11-24 15:15:51 +05:30
|
|
|
subject { pipeline.same_family_pipeline_ids.map(&:id) }
|
2020-07-28 23:09:34 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
context 'when pipeline is not child nor parent' do
|
|
|
|
it 'returns just the pipeline id' do
|
2020-11-24 15:15:51 +05:30
|
|
|
expect(subject).to contain_exactly(pipeline.id)
|
2020-07-28 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is child' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:parent) { create(:ci_pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:pipeline) { create(:ci_pipeline, child_of: parent) }
|
|
|
|
let!(:sibling) { create(:ci_pipeline, child_of: parent) }
|
2020-07-28 23:09:34 +05:30
|
|
|
|
|
|
|
it 'returns parent sibling and self ids' do
|
2020-11-24 15:15:51 +05:30
|
|
|
expect(subject).to contain_exactly(parent.id, pipeline.id, sibling.id)
|
2020-07-28 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is parent' do
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:child) { create(:ci_pipeline, child_of: pipeline) }
|
2020-07-28 23:09:34 +05:30
|
|
|
|
|
|
|
it 'returns self and child ids' do
|
2020-11-24 15:15:51 +05:30
|
|
|
expect(subject).to contain_exactly(pipeline.id, child.id)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is a child of a child pipeline' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:ancestor) { create(:ci_pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:parent) { create(:ci_pipeline, child_of: ancestor) }
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, child_of: parent) }
|
|
|
|
let!(:cousin_parent) { create(:ci_pipeline, child_of: ancestor) }
|
|
|
|
let!(:cousin) { create(:ci_pipeline, child_of: cousin_parent) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it 'returns all family ids' do
|
|
|
|
expect(subject).to contain_exactly(
|
|
|
|
ancestor.id, parent.id, cousin_parent.id, cousin.id, pipeline.id
|
|
|
|
)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is a triggered pipeline' do
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:upstream) { create(:ci_pipeline, project: create(:project), upstream_of: pipeline)}
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it 'returns self id' do
|
|
|
|
expect(subject).to contain_exactly(pipeline.id)
|
2020-07-28 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
describe '#root_ancestor' do
|
|
|
|
subject { pipeline.root_ancestor }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
context 'when pipeline is child of child pipeline' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:root_ancestor) { create(:ci_pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:parent_pipeline) { create(:ci_pipeline, child_of: root_ancestor) }
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, child_of: parent_pipeline) }
|
|
|
|
|
|
|
|
it 'returns the root ancestor' do
|
|
|
|
expect(subject).to eq(root_ancestor)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is root ancestor' do
|
|
|
|
let!(:child_pipeline) { create(:ci_pipeline, child_of: pipeline) }
|
|
|
|
|
|
|
|
it 'returns itself' do
|
|
|
|
expect(subject).to eq(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is standalone' do
|
|
|
|
it 'returns itself' do
|
|
|
|
expect(subject).to eq(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is multi-project downstream pipeline' do
|
|
|
|
let!(:upstream_pipeline) do
|
|
|
|
create(:ci_pipeline, project: create(:project), upstream_of: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'ignores cross project ancestors' do
|
|
|
|
expect(subject).to eq(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
describe '#stuck?' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_empty_pipeline, :created) }
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
before do
|
|
|
|
create(:ci_build, :pending, pipeline: pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is stuck' do
|
|
|
|
it 'is stuck' do
|
|
|
|
expect(pipeline).to be_stuck
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is not stuck' do
|
2017-09-10 17:25:29 +05:30
|
|
|
before do
|
2018-11-08 19:23:39 +05:30
|
|
|
create(:ci_runner, :instance, :online)
|
2017-09-10 17:25:29 +05:30
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
|
|
|
|
it 'is not stuck' do
|
|
|
|
expect(pipeline).not_to be_stuck
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '#add_error_message' do
|
|
|
|
let(:pipeline) { build_stubbed(:ci_pipeline) }
|
|
|
|
|
|
|
|
it 'adds a new pipeline error message' do
|
|
|
|
pipeline.add_error_message('The error message')
|
|
|
|
|
|
|
|
expect(pipeline.messages.map(&:content)).to contain_exactly('The error message')
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when feature flag ci_store_pipeline_messages is disabled' do
|
|
|
|
before do
|
|
|
|
stub_feature_flags(ci_store_pipeline_messages: false)
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'does not add pipeline error message' do
|
2020-07-28 23:09:34 +05:30
|
|
|
pipeline.add_error_message('The error message')
|
|
|
|
|
|
|
|
expect(pipeline.messages).to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
describe '#has_yaml_errors?' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build_stubbed(:ci_pipeline) }
|
|
|
|
|
2019-12-26 22:10:19 +05:30
|
|
|
context 'when yaml_errors is set' do
|
|
|
|
before do
|
|
|
|
pipeline.yaml_errors = 'File not found'
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
2019-12-26 22:10:19 +05:30
|
|
|
it 'returns true if yaml_errors is set' do
|
2017-08-17 22:00:37 +05:30
|
|
|
expect(pipeline).to have_yaml_errors
|
2019-12-26 22:10:19 +05:30
|
|
|
expect(pipeline.yaml_errors).to include('File not foun')
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-12-26 22:10:19 +05:30
|
|
|
it 'returns false if yaml_errors is not set' do
|
|
|
|
expect(pipeline).not_to have_yaml_errors
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'notifications when pipeline success or failed' do
|
2020-11-24 15:15:51 +05:30
|
|
|
let(:namespace) { create(:namespace) }
|
|
|
|
let(:project) { create(:project, :repository, namespace: namespace) }
|
2017-08-17 22:00:37 +05:30
|
|
|
|
|
|
|
let(:pipeline) do
|
|
|
|
create(:ci_pipeline,
|
|
|
|
project: project,
|
|
|
|
sha: project.commit('master').sha,
|
2019-09-04 21:01:54 +05:30
|
|
|
user: project.owner)
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
before do
|
2018-03-17 18:26:18 +05:30
|
|
|
project.add_developer(pipeline.user)
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2017-09-10 17:25:29 +05:30
|
|
|
pipeline.user.global_notification_setting
|
2020-11-24 15:15:51 +05:30
|
|
|
.update!(level: 'custom', failed_pipeline: true, success_pipeline: true)
|
2017-08-17 22:00:37 +05:30
|
|
|
|
|
|
|
perform_enqueued_jobs do
|
|
|
|
pipeline.enqueue
|
|
|
|
pipeline.run
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
shared_examples 'sending a notification' do
|
2019-12-26 22:10:19 +05:30
|
|
|
it 'sends an email', :sidekiq_might_not_need_inline do
|
2017-08-17 22:00:37 +05:30
|
|
|
should_only_email(pipeline.user, kind: :bcc)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
shared_examples 'not sending any notification' do
|
|
|
|
it 'does not send any email' do
|
|
|
|
should_not_email_anyone
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
context 'with success pipeline' do
|
|
|
|
it_behaves_like 'sending a notification' do
|
|
|
|
before do
|
|
|
|
perform_enqueued_jobs do
|
|
|
|
pipeline.succeed
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'enqueues PipelineNotificationWorker' do
|
|
|
|
expect(PipelineNotificationWorker)
|
|
|
|
.to receive(:perform_async).with(pipeline.id, ref_status: :success)
|
2020-04-08 14:13:33 +05:30
|
|
|
|
|
|
|
pipeline.succeed
|
|
|
|
end
|
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
context 'when pipeline is not the latest' do
|
2020-04-08 14:13:33 +05:30
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_pipeline, :success, ci_ref: pipeline.ci_ref)
|
2020-04-08 14:13:33 +05:30
|
|
|
end
|
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
it 'does not pass ref_status' do
|
|
|
|
expect(PipelineNotificationWorker)
|
|
|
|
.to receive(:perform_async).with(pipeline.id, ref_status: nil)
|
2020-04-08 14:13:33 +05:30
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
pipeline.succeed!
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
2020-04-08 14:13:33 +05:30
|
|
|
end
|
|
|
|
|
2017-08-17 22:00:37 +05:30
|
|
|
context 'with failed pipeline' do
|
2020-04-08 14:13:33 +05:30
|
|
|
it_behaves_like 'sending a notification' do
|
|
|
|
before do
|
|
|
|
perform_enqueued_jobs do
|
|
|
|
create(:ci_build, :failed, pipeline: pipeline)
|
|
|
|
create(:generic_commit_status, :failed, pipeline: pipeline)
|
2017-08-17 22:00:37 +05:30
|
|
|
|
2020-04-08 14:13:33 +05:30
|
|
|
pipeline.drop
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
it 'enqueues PipelineNotificationWorker' do
|
|
|
|
expect(PipelineNotificationWorker)
|
|
|
|
.to receive(:perform_async).with(pipeline.id, ref_status: :failed)
|
|
|
|
|
|
|
|
pipeline.drop
|
|
|
|
end
|
2017-08-17 22:00:37 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'with skipped pipeline' do
|
|
|
|
before do
|
|
|
|
perform_enqueued_jobs do
|
|
|
|
pipeline.skip
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it_behaves_like 'not sending any notification'
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with cancelled pipeline' do
|
|
|
|
before do
|
|
|
|
perform_enqueued_jobs do
|
|
|
|
pipeline.cancel
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it_behaves_like 'not sending any notification'
|
|
|
|
end
|
|
|
|
end
|
2018-03-17 18:26:18 +05:30
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
describe 'updates ci_ref when pipeline finished' do
|
|
|
|
context 'when ci_ref exists' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, :running) }
|
|
|
|
|
|
|
|
it 'updates the ci_ref' do
|
|
|
|
expect(pipeline.ci_ref)
|
|
|
|
.to receive(:update_status_by!).with(pipeline).and_call_original
|
|
|
|
|
|
|
|
pipeline.succeed!
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when ci_ref does not exist' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, :running, ci_ref_presence: false) }
|
|
|
|
|
|
|
|
it 'does not raise an exception' do
|
|
|
|
expect { pipeline.succeed! }.not_to raise_error
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#ensure_ci_ref!' do
|
|
|
|
subject { pipeline.ensure_ci_ref! }
|
|
|
|
|
|
|
|
context 'when ci_ref does not exist yet' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline, ci_ref_presence: false) }
|
|
|
|
|
|
|
|
it 'creates a new ci_ref and assigns it' do
|
|
|
|
expect { subject }.to change { Ci::Ref.count }.by(1)
|
|
|
|
|
|
|
|
expect(pipeline.ci_ref).to be_present
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when ci_ref already exists' do
|
|
|
|
let!(:pipeline) { create(:ci_pipeline) }
|
|
|
|
|
|
|
|
it 'fetches a new ci_ref and assigns it' do
|
|
|
|
expect { subject }.not_to change { Ci::Ref.count }
|
|
|
|
|
|
|
|
expect(pipeline.ci_ref).to be_present
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-01-03 14:25:43 +05:30
|
|
|
describe '#builds_in_self_and_descendants' do
|
|
|
|
subject(:builds) { pipeline.builds_in_self_and_descendants }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline) }
|
2021-01-03 14:25:43 +05:30
|
|
|
let!(:build) { create(:ci_build, pipeline: pipeline) }
|
|
|
|
|
|
|
|
context 'when pipeline is standalone' do
|
|
|
|
it 'returns the list of builds' do
|
|
|
|
expect(builds).to contain_exactly(build)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is parent of another pipeline' do
|
|
|
|
let(:child_pipeline) { create(:ci_pipeline, child_of: pipeline) }
|
|
|
|
let!(:child_build) { create(:ci_build, pipeline: child_pipeline) }
|
|
|
|
|
|
|
|
it 'returns the list of builds' do
|
|
|
|
expect(builds).to contain_exactly(build, child_build)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is parent of another parent pipeline' do
|
|
|
|
let(:child_pipeline) { create(:ci_pipeline, child_of: pipeline) }
|
|
|
|
let!(:child_build) { create(:ci_build, pipeline: child_pipeline) }
|
|
|
|
let(:child_of_child_pipeline) { create(:ci_pipeline, child_of: child_pipeline) }
|
|
|
|
let!(:child_of_child_build) { create(:ci_build, pipeline: child_of_child_pipeline) }
|
|
|
|
|
|
|
|
it 'returns the list of builds' do
|
|
|
|
expect(builds).to contain_exactly(build, child_build, child_of_child_build)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#build_with_artifacts_in_self_and_descendants' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
2021-01-03 14:25:43 +05:30
|
|
|
let!(:build) { create(:ci_build, name: 'test', pipeline: pipeline) }
|
|
|
|
let(:child_pipeline) { create(:ci_pipeline, child_of: pipeline) }
|
|
|
|
let!(:child_build) { create(:ci_build, :artifacts, name: 'test', pipeline: child_pipeline) }
|
|
|
|
|
|
|
|
it 'returns the build with a given name, having artifacts' do
|
|
|
|
expect(pipeline.build_with_artifacts_in_self_and_descendants('test')).to eq(child_build)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when same job name is present in both parent and child pipeline' do
|
|
|
|
let!(:build) { create(:ci_build, :artifacts, name: 'test', pipeline: pipeline) }
|
|
|
|
|
|
|
|
it 'returns the job in the parent pipeline' do
|
|
|
|
expect(pipeline.build_with_artifacts_in_self_and_descendants('test')).to eq(build)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-08 14:13:33 +05:30
|
|
|
describe '#find_job_with_archive_artifacts' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline) }
|
2020-04-08 14:13:33 +05:30
|
|
|
let!(:old_job) { create(:ci_build, name: 'rspec', retried: true, pipeline: pipeline) }
|
|
|
|
let!(:job_without_artifacts) { create(:ci_build, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let!(:expected_job) { create(:ci_build, :artifacts, name: 'rspec', pipeline: pipeline ) }
|
|
|
|
let!(:different_job) { create(:ci_build, name: 'deploy', pipeline: pipeline) }
|
|
|
|
|
|
|
|
subject { pipeline.find_job_with_archive_artifacts('rspec') }
|
|
|
|
|
|
|
|
it 'finds the expected job' do
|
|
|
|
expect(subject).to eq(expected_job)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-03-17 18:26:18 +05:30
|
|
|
describe '#latest_builds_with_artifacts' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline) }
|
2019-07-31 22:56:46 +05:30
|
|
|
let!(:fresh_build) { create(:ci_build, :success, :artifacts, pipeline: pipeline) }
|
|
|
|
let!(:stale_build) { create(:ci_build, :success, :expired, :artifacts, pipeline: pipeline) }
|
2018-03-17 18:26:18 +05:30
|
|
|
|
|
|
|
it 'returns an Array' do
|
|
|
|
expect(pipeline.latest_builds_with_artifacts).to be_an_instance_of(Array)
|
|
|
|
end
|
|
|
|
|
2019-07-31 22:56:46 +05:30
|
|
|
it 'returns the latest builds with non-expired artifacts' do
|
|
|
|
expect(pipeline.latest_builds_with_artifacts).to contain_exactly(fresh_build)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not return builds with expired artifacts' do
|
|
|
|
expect(pipeline.latest_builds_with_artifacts).not_to include(stale_build)
|
2018-03-17 18:26:18 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'memoizes the returned relation' do
|
|
|
|
query_count = ActiveRecord::QueryRecorder
|
|
|
|
.new { 2.times { pipeline.latest_builds_with_artifacts.to_a } }
|
|
|
|
.count
|
|
|
|
|
|
|
|
expect(query_count).to eq(1)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '#batch_lookup_report_artifact_for_file_type' do
|
|
|
|
context 'with code quality report artifact' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :with_codequality_reports) }
|
2020-07-28 23:09:34 +05:30
|
|
|
|
|
|
|
it "returns the code quality artifact" do
|
|
|
|
expect(pipeline.batch_lookup_report_artifact_for_file_type(:codequality)).to eq(pipeline.job_artifacts.sample)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
describe '#latest_report_builds' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, project: project) }
|
|
|
|
|
2020-06-23 00:09:42 +05:30
|
|
|
it 'returns build with test artifacts' do
|
2021-04-17 20:07:23 +05:30
|
|
|
test_build = create(:ci_build, :test_reports, pipeline: pipeline)
|
|
|
|
coverage_build = create(:ci_build, :coverage_reports, pipeline: pipeline)
|
2020-06-23 00:09:42 +05:30
|
|
|
create(:ci_build, :artifacts, pipeline: pipeline, project: project)
|
|
|
|
|
|
|
|
expect(pipeline.latest_report_builds).to contain_exactly(test_build, coverage_build)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'filters builds by scope' do
|
2021-04-17 20:07:23 +05:30
|
|
|
test_build = create(:ci_build, :test_reports, pipeline: pipeline)
|
|
|
|
create(:ci_build, :coverage_reports, pipeline: pipeline)
|
2020-06-23 00:09:42 +05:30
|
|
|
|
|
|
|
expect(pipeline.latest_report_builds(Ci::JobArtifact.test_reports)).to contain_exactly(test_build)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'only returns not retried builds' do
|
2021-04-17 20:07:23 +05:30
|
|
|
test_build = create(:ci_build, :test_reports, pipeline: pipeline)
|
|
|
|
create(:ci_build, :test_reports, :retried, pipeline: pipeline)
|
2020-06-23 00:09:42 +05:30
|
|
|
|
|
|
|
expect(pipeline.latest_report_builds).to contain_exactly(test_build)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-07 11:18:12 +05:30
|
|
|
describe '#has_reports?' do
|
|
|
|
subject { pipeline.has_reports?(Ci::JobArtifact.test_reports) }
|
2018-11-18 11:00:15 +05:30
|
|
|
|
|
|
|
context 'when pipeline has builds with test reports' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :test_reports, pipeline: pipeline)
|
2018-11-18 11:00:15 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline status is running' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :running) }
|
2018-11-18 11:00:15 +05:30
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline status is success' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2018-11-18 11:00:15 +05:30
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have builds with test reports' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :artifacts, pipeline: pipeline)
|
2018-11-18 11:00:15 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2018-11-18 11:00:15 +05:30
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when retried build has test reports' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :retried, :test_reports, pipeline: pipeline)
|
2018-11-18 11:00:15 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2018-11-18 11:00:15 +05:30
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
describe '#has_coverage_reports?' do
|
|
|
|
subject { pipeline.has_coverage_reports? }
|
|
|
|
|
|
|
|
context 'when pipeline has a code coverage artifact' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :with_coverage_report_artifact, :running) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_truthy }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have a code coverage artifact' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_falsey }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#can_generate_coverage_reports?' do
|
|
|
|
subject { pipeline.can_generate_coverage_reports? }
|
|
|
|
|
|
|
|
context 'when pipeline has builds with coverage reports' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :coverage_reports, pipeline: pipeline)
|
2020-11-24 15:15:51 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline status is running' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :running) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_falsey }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline status is success' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_truthy }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have builds with coverage reports' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :artifacts, pipeline: pipeline)
|
2020-11-24 15:15:51 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_falsey }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-03-11 19:13:27 +05:30
|
|
|
describe '#has_codequality_mr_diff_report?' do
|
|
|
|
subject { pipeline.has_codequality_mr_diff_report? }
|
|
|
|
|
|
|
|
context 'when pipeline has a codequality mr diff report' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :with_codequality_mr_diff_report, :running) }
|
2021-03-11 19:13:27 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_truthy }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have a codequality mr diff report' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2021-03-11 19:13:27 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_falsey }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#can_generate_codequality_reports?' do
|
|
|
|
subject { pipeline.can_generate_codequality_reports? }
|
|
|
|
|
|
|
|
context 'when pipeline has builds with codequality reports' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :codequality_reports, pipeline: pipeline)
|
2021-03-11 19:13:27 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline status is running' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :running) }
|
2021-03-11 19:13:27 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_falsey }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline status is success' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2021-03-11 19:13:27 +05:30
|
|
|
|
|
|
|
it 'can generate a codequality report' do
|
|
|
|
expect(subject).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when feature is disabled' do
|
|
|
|
before do
|
|
|
|
stub_feature_flags(codequality_mr_diff: false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'can not generate a codequality report' do
|
|
|
|
expect(subject).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have builds with codequality reports' do
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :artifacts, pipeline: pipeline)
|
2021-03-11 19:13:27 +05:30
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2021-03-11 19:13:27 +05:30
|
|
|
|
|
|
|
it { expect(subject).to be_falsey }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '#test_report_summary' do
|
|
|
|
subject { pipeline.test_report_summary }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :success) }
|
2020-07-28 23:09:34 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
context 'when pipeline has multiple builds with report results' do
|
2020-07-28 23:09:34 +05:30
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :success, :report_results, name: 'rspec', pipeline: pipeline)
|
|
|
|
create(:ci_build, :success, :report_results, name: 'java', pipeline: pipeline)
|
2020-07-28 23:09:34 +05:30
|
|
|
end
|
|
|
|
|
2020-10-24 23:57:45 +05:30
|
|
|
it 'returns test report summary with collected data' do
|
|
|
|
expect(subject.total).to include(time: 0.84, count: 4, success: 0, failed: 0, skipped: 0, error: 4)
|
2020-07-28 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have any builds with report results' do
|
2020-10-24 23:57:45 +05:30
|
|
|
it 'returns empty test report summary' do
|
|
|
|
expect(subject.total).to include(time: 0, count: 0, success: 0, failed: 0, skipped: 0, error: 0)
|
2020-07-28 23:09:34 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-11-18 11:00:15 +05:30
|
|
|
describe '#test_reports' do
|
|
|
|
subject { pipeline.test_reports }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
|
|
|
|
2018-11-18 11:00:15 +05:30
|
|
|
context 'when pipeline has multiple builds with test reports' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:build_rspec) { create(:ci_build, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let!(:build_java) { create(:ci_build, :success, name: 'java', pipeline: pipeline) }
|
2018-11-18 11:00:15 +05:30
|
|
|
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_job_artifact, :junit, job: build_rspec)
|
|
|
|
create(:ci_job_artifact, :junit_with_ant, job: build_java)
|
2018-11-18 11:00:15 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns test reports with collected data' do
|
|
|
|
expect(subject.total_count).to be(7)
|
|
|
|
expect(subject.success_count).to be(5)
|
|
|
|
expect(subject.failed_count).to be(2)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when builds are retried' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:build_rspec) { create(:ci_build, :retried, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let!(:build_java) { create(:ci_build, :retried, :success, name: 'java', pipeline: pipeline) }
|
2018-11-18 11:00:15 +05:30
|
|
|
|
|
|
|
it 'does not take retried builds into account' do
|
|
|
|
expect(subject.total_count).to be(0)
|
|
|
|
expect(subject.success_count).to be(0)
|
|
|
|
expect(subject.failed_count).to be(0)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have any builds with test reports' do
|
|
|
|
it 'returns empty test reports' do
|
|
|
|
expect(subject.total_count).to be(0)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-05-24 23:13:21 +05:30
|
|
|
describe '#accessibility_reports' do
|
|
|
|
subject { pipeline.accessibility_reports }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
|
|
|
|
2020-05-24 23:13:21 +05:30
|
|
|
context 'when pipeline has multiple builds with accessibility reports' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:build_rspec) { create(:ci_build, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let(:build_golang) { create(:ci_build, :success, name: 'golang', pipeline: pipeline) }
|
2020-05-24 23:13:21 +05:30
|
|
|
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_job_artifact, :accessibility, job: build_rspec)
|
|
|
|
create(:ci_job_artifact, :accessibility_without_errors, job: build_golang)
|
2020-05-24 23:13:21 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns accessibility report with collected data' do
|
|
|
|
expect(subject.urls.keys).to match_array([
|
|
|
|
"https://pa11y.org/",
|
|
|
|
"https://about.gitlab.com/"
|
|
|
|
])
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when builds are retried' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:build_rspec) { create(:ci_build, :retried, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let(:build_golang) { create(:ci_build, :retried, :success, name: 'golang', pipeline: pipeline) }
|
2020-05-24 23:13:21 +05:30
|
|
|
|
|
|
|
it 'returns empty urls for accessibility reports' do
|
|
|
|
expect(subject.urls).to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have any builds with accessibility reports' do
|
|
|
|
it 'returns empty urls for accessibility reports' do
|
|
|
|
expect(subject.urls).to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-08 14:13:33 +05:30
|
|
|
describe '#coverage_reports' do
|
|
|
|
subject { pipeline.coverage_reports }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
|
|
|
|
2020-04-08 14:13:33 +05:30
|
|
|
context 'when pipeline has multiple builds with coverage reports' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:build_rspec) { create(:ci_build, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let!(:build_golang) { create(:ci_build, :success, name: 'golang', pipeline: pipeline) }
|
2020-04-08 14:13:33 +05:30
|
|
|
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_job_artifact, :cobertura, job: build_rspec)
|
|
|
|
create(:ci_job_artifact, :coverage_gocov_xml, job: build_golang)
|
2020-04-08 14:13:33 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns coverage reports with collected data' do
|
|
|
|
expect(subject.files.keys).to match_array([
|
|
|
|
"auth/token.go",
|
|
|
|
"auth/rpccredentials.go",
|
|
|
|
"app/controllers/abuse_reports_controller.rb"
|
|
|
|
])
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'does not execute N+1 queries' do
|
2021-04-17 20:07:23 +05:30
|
|
|
single_build_pipeline = create(:ci_empty_pipeline, :created)
|
|
|
|
single_rspec = create(:ci_build, :success, name: 'rspec', pipeline: single_build_pipeline)
|
2021-02-22 17:27:13 +05:30
|
|
|
create(:ci_job_artifact, :cobertura, job: single_rspec, project: project)
|
|
|
|
|
|
|
|
control = ActiveRecord::QueryRecorder.new { single_build_pipeline.coverage_reports }
|
|
|
|
|
|
|
|
expect { subject }.not_to exceed_query_limit(control)
|
|
|
|
end
|
|
|
|
|
2020-04-08 14:13:33 +05:30
|
|
|
context 'when builds are retried' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:build_rspec) { create(:ci_build, :retried, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let!(:build_golang) { create(:ci_build, :retried, :success, name: 'golang', pipeline: pipeline) }
|
2020-04-08 14:13:33 +05:30
|
|
|
|
|
|
|
it 'does not take retried builds into account' do
|
|
|
|
expect(subject.files).to eql({})
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have any builds with coverage reports' do
|
|
|
|
it 'returns empty coverage reports' do
|
|
|
|
expect(subject.files).to eql({})
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
describe '#codequality_reports' do
|
|
|
|
subject(:codequality_reports) { pipeline.codequality_reports }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
context 'when pipeline has multiple builds with codequality reports' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:build_rspec) { create(:ci_build, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let(:build_golang) { create(:ci_build, :success, name: 'golang', pipeline: pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
before do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_job_artifact, :codequality, job: build_rspec)
|
|
|
|
create(:ci_job_artifact, :codequality_without_errors, job: build_golang)
|
2021-02-22 17:27:13 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns codequality report with collected data' do
|
|
|
|
expect(codequality_reports.degradations_count).to eq(3)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when builds are retried' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:build_rspec) { create(:ci_build, :retried, :success, name: 'rspec', pipeline: pipeline) }
|
|
|
|
let(:build_golang) { create(:ci_build, :retried, :success, name: 'golang', pipeline: pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
it 'returns a codequality reports without degradations' do
|
|
|
|
expect(codequality_reports.degradations).to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have any builds with codequality reports' do
|
|
|
|
it 'returns codequality reports without degradations' do
|
|
|
|
expect(codequality_reports.degradations).to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-03-17 18:26:18 +05:30
|
|
|
describe '#total_size' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline) }
|
2018-03-17 18:26:18 +05:30
|
|
|
let!(:build_job1) { create(:ci_build, pipeline: pipeline, stage_idx: 0) }
|
|
|
|
let!(:build_job2) { create(:ci_build, pipeline: pipeline, stage_idx: 0) }
|
|
|
|
let!(:test_job_failed_and_retried) { create(:ci_build, :failed, :retried, pipeline: pipeline, stage_idx: 1) }
|
|
|
|
let!(:second_test_job) { create(:ci_build, pipeline: pipeline, stage_idx: 1) }
|
|
|
|
let!(:deploy_job) { create(:ci_build, pipeline: pipeline, stage_idx: 2) }
|
|
|
|
|
|
|
|
it 'returns all jobs (including failed and retried)' do
|
|
|
|
expect(pipeline.total_size).to eq(5)
|
|
|
|
end
|
|
|
|
end
|
2018-11-20 20:47:30 +05:30
|
|
|
|
|
|
|
describe '#status' do
|
|
|
|
context 'when transitioning to failed' do
|
|
|
|
context 'when pipeline has autodevops as source' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, :running, :auto_devops_source) }
|
|
|
|
|
|
|
|
it 'calls autodevops disable service' do
|
|
|
|
expect(AutoDevops::DisableWorker).to receive(:perform_async).with(pipeline.id)
|
|
|
|
|
|
|
|
pipeline.drop
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline has other source' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, :running, :repository_source) }
|
|
|
|
|
|
|
|
it 'does not call auto devops disable service' do
|
|
|
|
expect(AutoDevops::DisableWorker).not_to receive(:perform_async)
|
|
|
|
|
|
|
|
pipeline.drop
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2018-12-05 23:21:45 +05:30
|
|
|
|
|
|
|
describe '#default_branch?' do
|
|
|
|
subject { pipeline.default_branch? }
|
|
|
|
|
|
|
|
context 'when pipeline ref is the default branch of the project' do
|
|
|
|
let(:pipeline) do
|
2021-04-17 20:07:23 +05:30
|
|
|
build(:ci_empty_pipeline, :created, project: project, ref: project.default_branch)
|
2018-12-05 23:21:45 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true" do
|
|
|
|
expect(subject).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline ref is not the default branch of the project' do
|
|
|
|
let(:pipeline) do
|
2021-04-17 20:07:23 +05:30
|
|
|
build(:ci_empty_pipeline, :created, project: project, ref: 'another_branch')
|
2018-12-05 23:21:45 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false" do
|
|
|
|
expect(subject).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2019-07-31 22:56:46 +05:30
|
|
|
|
|
|
|
describe '#find_stage_by_name' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
2019-07-31 22:56:46 +05:30
|
|
|
let(:stage_name) { 'test' }
|
|
|
|
|
|
|
|
let(:stage) do
|
|
|
|
create(:ci_stage_entity,
|
|
|
|
pipeline: pipeline,
|
|
|
|
project: pipeline.project,
|
|
|
|
name: 'test')
|
|
|
|
end
|
|
|
|
|
|
|
|
before do
|
|
|
|
create_list(:ci_build, 2, pipeline: pipeline, stage: stage.name)
|
|
|
|
end
|
|
|
|
|
|
|
|
subject { pipeline.find_stage_by_name!(stage_name) }
|
|
|
|
|
|
|
|
context 'when stage exists' do
|
|
|
|
it { is_expected.to eq(stage) }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when stage does not exist' do
|
|
|
|
let(:stage_name) { 'build' }
|
|
|
|
|
|
|
|
it 'raises an ActiveRecord exception' do
|
|
|
|
expect do
|
|
|
|
subject
|
|
|
|
end.to raise_exception(ActiveRecord::RecordNotFound)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2019-09-30 21:07:59 +05:30
|
|
|
|
2020-07-28 23:09:34 +05:30
|
|
|
describe '#full_error_messages' do
|
|
|
|
subject { pipeline.full_error_messages }
|
2019-09-30 21:07:59 +05:30
|
|
|
|
|
|
|
before do
|
|
|
|
pipeline.valid?
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline has errors' do
|
|
|
|
let(:pipeline) { build(:ci_pipeline, sha: nil, ref: nil) }
|
|
|
|
|
|
|
|
it 'returns the full error messages' do
|
|
|
|
is_expected.to eq("Sha can't be blank and Ref can't be blank")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline does not have errors' do
|
|
|
|
let(:pipeline) { build(:ci_pipeline) }
|
|
|
|
|
|
|
|
it 'returns empty string' do
|
|
|
|
is_expected.to be_empty
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2020-03-13 15:44:24 +05:30
|
|
|
|
2020-04-08 14:13:33 +05:30
|
|
|
describe '#created_successfully?' do
|
|
|
|
subject { pipeline.created_successfully? }
|
|
|
|
|
|
|
|
context 'when pipeline is not persisted' do
|
|
|
|
let(:pipeline) { build(:ci_pipeline) }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is persisted' do
|
|
|
|
context 'when pipeline has failure reasons' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, failure_reason: :config_error) }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline has no failure reasons' do
|
|
|
|
let(:pipeline) { create(:ci_pipeline, failure_reason: nil) }
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
describe '#parent_pipeline' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be_with_reload(:pipeline) { create(:ci_pipeline) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
context 'when pipeline is triggered by a pipeline from the same project' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:upstream_pipeline) { create(:ci_pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, child_of: upstream_pipeline) }
|
2020-03-13 15:44:24 +05:30
|
|
|
|
|
|
|
it 'returns the parent pipeline' do
|
|
|
|
expect(pipeline.parent_pipeline).to eq(upstream_pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is child' do
|
|
|
|
expect(pipeline).to be_child
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is triggered by a pipeline from another project' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline) }
|
2021-02-22 17:27:13 +05:30
|
|
|
let!(:upstream_pipeline) { create(:ci_pipeline, project: create(:project), upstream_of: pipeline) }
|
2020-03-13 15:44:24 +05:30
|
|
|
|
|
|
|
it 'returns nil' do
|
|
|
|
expect(pipeline.parent_pipeline).to be_nil
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not child' do
|
|
|
|
expect(pipeline).not_to be_child
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is not triggered by a pipeline' do
|
2021-02-22 17:27:13 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline) }
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
it 'returns nil' do
|
|
|
|
expect(pipeline.parent_pipeline).to be_nil
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not child' do
|
|
|
|
expect(pipeline).not_to be_child
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#child_pipelines' do
|
2020-11-24 15:15:51 +05:30
|
|
|
let_it_be(:project) { create(:project) }
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be_with_reload(:pipeline) { create(:ci_pipeline, project: project) }
|
2020-03-13 15:44:24 +05:30
|
|
|
|
|
|
|
context 'when pipeline triggered other pipelines on same project' do
|
|
|
|
let(:downstream_pipeline) { create(:ci_pipeline, project: pipeline.project) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create(:ci_sources_pipeline,
|
|
|
|
source_pipeline: pipeline,
|
|
|
|
source_project: pipeline.project,
|
|
|
|
pipeline: downstream_pipeline,
|
|
|
|
project: pipeline.project)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns the child pipelines' do
|
|
|
|
expect(pipeline.child_pipelines).to eq [downstream_pipeline]
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is parent' do
|
|
|
|
expect(pipeline).to be_parent
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline triggered other pipelines on another project' do
|
|
|
|
let(:downstream_pipeline) { create(:ci_pipeline) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create(:ci_sources_pipeline,
|
|
|
|
source_pipeline: pipeline,
|
|
|
|
source_project: pipeline.project,
|
|
|
|
pipeline: downstream_pipeline,
|
|
|
|
project: downstream_pipeline.project)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns empty array' do
|
|
|
|
expect(pipeline.child_pipelines).to be_empty
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not parent' do
|
|
|
|
expect(pipeline).not_to be_parent
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline did not trigger any pipelines' do
|
|
|
|
it 'returns empty array' do
|
|
|
|
expect(pipeline.child_pipelines).to be_empty
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is not parent' do
|
|
|
|
expect(pipeline).not_to be_parent
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'upstream status interactions' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be_with_reload(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
|
2020-03-13 15:44:24 +05:30
|
|
|
context 'when a pipeline has an upstream status' do
|
|
|
|
context 'when an upstream status is a bridge' do
|
|
|
|
let(:bridge) { create(:ci_bridge, status: :pending) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create(:ci_sources_pipeline, pipeline: pipeline, source_job: bridge)
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#bridge_triggered?' do
|
|
|
|
it 'is a pipeline triggered by a bridge' do
|
|
|
|
expect(pipeline).to be_bridge_triggered
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#source_job' do
|
|
|
|
it 'has a correct source job' do
|
|
|
|
expect(pipeline.source_job).to eq bridge
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#source_bridge' do
|
|
|
|
it 'has a correct bridge source' do
|
|
|
|
expect(pipeline.source_bridge).to eq bridge
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when an upstream status is a build' do
|
|
|
|
let(:build) { create(:ci_build) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create(:ci_sources_pipeline, pipeline: pipeline, source_job: build)
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#bridge_triggered?' do
|
|
|
|
it 'is a pipeline that has not been triggered by a bridge' do
|
|
|
|
expect(pipeline).not_to be_bridge_triggered
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#source_job' do
|
|
|
|
it 'has a correct source job' do
|
|
|
|
expect(pipeline.source_job).to eq build
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#source_bridge' do
|
|
|
|
it 'does not have a bridge source' do
|
|
|
|
expect(pipeline.source_bridge).to be_nil
|
|
|
|
end
|
|
|
|
end
|
2020-04-22 19:07:51 +05:30
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2020-03-13 15:44:24 +05:30
|
|
|
|
2020-04-22 19:07:51 +05:30
|
|
|
describe '#source_ref_path' do
|
|
|
|
subject { pipeline.source_ref_path }
|
2020-04-08 14:13:33 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
|
2020-04-22 19:07:51 +05:30
|
|
|
context 'when pipeline is for a branch' do
|
|
|
|
it { is_expected.to eq(Gitlab::Git::BRANCH_REF_PREFIX + pipeline.source_ref.to_s) }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is for a merge request' do
|
|
|
|
let(:merge_request) { create(:merge_request, source_project: project) }
|
|
|
|
let(:pipeline) { create(:ci_pipeline, project: project, head_pipeline_of: merge_request) }
|
|
|
|
|
|
|
|
it { is_expected.to eq(Gitlab::Git::BRANCH_REF_PREFIX + pipeline.source_ref.to_s) }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is for a tag' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { create(:ci_pipeline, tag: true) }
|
2020-04-22 19:07:51 +05:30
|
|
|
|
|
|
|
it { is_expected.to eq(Gitlab::Git::TAG_REF_PREFIX + pipeline.source_ref.to_s) }
|
2020-03-13 15:44:24 +05:30
|
|
|
end
|
|
|
|
end
|
2020-11-24 15:15:51 +05:30
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
describe '#builds_with_coverage' do
|
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
it 'returns builds with coverage only' do
|
|
|
|
rspec = create(:ci_build, name: 'rspec', coverage: 97.1, pipeline: pipeline)
|
|
|
|
jest = create(:ci_build, name: 'jest', coverage: 94.1, pipeline: pipeline)
|
|
|
|
karma = create(:ci_build, name: 'karma', coverage: nil, pipeline: pipeline)
|
|
|
|
|
|
|
|
builds = pipeline.builds_with_coverage
|
|
|
|
|
|
|
|
expect(builds).to include(rspec, jest)
|
|
|
|
expect(builds).not_to include(karma)
|
|
|
|
end
|
2021-01-03 14:25:43 +05:30
|
|
|
|
|
|
|
it 'returns only latest builds' do
|
|
|
|
obsolete = create(:ci_build, name: "jest", coverage: 10.12, pipeline: pipeline, retried: true)
|
|
|
|
retried = create(:ci_build, name: "jest", coverage: 20.11, pipeline: pipeline)
|
|
|
|
|
|
|
|
builds = pipeline.builds_with_coverage
|
|
|
|
|
|
|
|
expect(builds).to include(retried)
|
|
|
|
expect(builds).not_to include(obsolete)
|
|
|
|
end
|
2020-11-24 15:15:51 +05:30
|
|
|
end
|
|
|
|
|
|
|
|
describe '#base_and_ancestors' do
|
|
|
|
subject { pipeline.base_and_ancestors(same_project: same_project) }
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
let(:same_project) { false }
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
context 'when pipeline is not child nor parent' do
|
|
|
|
it 'returns just the pipeline itself' do
|
|
|
|
expect(subject).to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is child' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:parent) { create(:ci_pipeline) }
|
|
|
|
let(:sibling) { create(:ci_pipeline) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
before do
|
|
|
|
create_source_pipeline(parent, pipeline)
|
|
|
|
create_source_pipeline(parent, sibling)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns parent and self' do
|
|
|
|
expect(subject).to contain_exactly(parent, pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is parent' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:child) { create(:ci_pipeline) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
before do
|
|
|
|
create_source_pipeline(pipeline, child)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns self' do
|
|
|
|
expect(subject).to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is a child of a child pipeline' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
let(:ancestor) { create(:ci_pipeline) }
|
|
|
|
let(:parent) { create(:ci_pipeline) }
|
2020-11-24 15:15:51 +05:30
|
|
|
|
|
|
|
before do
|
|
|
|
create_source_pipeline(ancestor, parent)
|
|
|
|
create_source_pipeline(parent, pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns self, parent and ancestor' do
|
|
|
|
expect(subject).to contain_exactly(ancestor, parent, pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pipeline is a triggered pipeline' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, :created) }
|
2020-11-24 15:15:51 +05:30
|
|
|
let(:upstream) { create(:ci_pipeline, project: create(:project)) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
create_source_pipeline(upstream, pipeline)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'same_project: false' do
|
|
|
|
it 'returns upstream and self' do
|
|
|
|
expect(subject).to contain_exactly(pipeline, upstream)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'same_project: true' do
|
|
|
|
let(:same_project) { true }
|
|
|
|
|
|
|
|
it 'returns self' do
|
|
|
|
expect(subject).to contain_exactly(pipeline)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'reset_ancestor_bridges!' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
|
2020-11-24 15:15:51 +05:30
|
|
|
context 'when the pipeline is a child pipeline and the bridge is depended' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:parent_pipeline) { create(:ci_pipeline) }
|
2020-11-24 15:15:51 +05:30
|
|
|
let!(:bridge) { create_bridge(parent_pipeline, pipeline, true) }
|
|
|
|
|
|
|
|
it 'marks source bridge as pending' do
|
|
|
|
pipeline.reset_ancestor_bridges!
|
|
|
|
|
|
|
|
expect(bridge.reload).to be_pending
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the parent pipeline has a dependent upstream pipeline' do
|
|
|
|
let!(:upstream_bridge) do
|
|
|
|
create_bridge(create(:ci_pipeline, project: create(:project)), parent_pipeline, true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'marks all source bridges as pending' do
|
|
|
|
pipeline.reset_ancestor_bridges!
|
|
|
|
|
|
|
|
expect(bridge.reload).to be_pending
|
|
|
|
expect(upstream_bridge.reload).to be_pending
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the pipeline is a child pipeline and the bridge is not depended' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let!(:parent_pipeline) { create(:ci_pipeline) }
|
2020-11-24 15:15:51 +05:30
|
|
|
let!(:bridge) { create_bridge(parent_pipeline, pipeline, false) }
|
|
|
|
|
|
|
|
it 'does not touch source bridge' do
|
|
|
|
pipeline.reset_ancestor_bridges!
|
|
|
|
|
|
|
|
expect(bridge.reload).to be_success
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the parent pipeline has a dependent upstream pipeline' do
|
|
|
|
let!(:upstream_bridge) do
|
|
|
|
create_bridge(create(:ci_pipeline, project: create(:project)), parent_pipeline, true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not touch any source bridge' do
|
|
|
|
pipeline.reset_ancestor_bridges!
|
|
|
|
|
|
|
|
expect(bridge.reload).to be_success
|
|
|
|
expect(upstream_bridge.reload).to be_success
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
|
|
|
|
def create_bridge(upstream, downstream, depend = false)
|
|
|
|
options = depend ? { trigger: { strategy: 'depend' } } : {}
|
|
|
|
|
|
|
|
bridge = create(:ci_bridge, pipeline: upstream, status: 'success', options: options)
|
|
|
|
create(:ci_sources_pipeline, pipeline: downstream, source_job: bridge)
|
|
|
|
|
|
|
|
bridge
|
|
|
|
end
|
|
|
|
end
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
describe 'test failure history processing' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let(:pipeline) { build(:ci_pipeline, :created) }
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'performs the service asynchronously when the pipeline is completed' do
|
|
|
|
service = double
|
|
|
|
|
|
|
|
expect(Ci::TestFailureHistoryService).to receive(:new).with(pipeline).and_return(service)
|
|
|
|
expect(service).to receive_message_chain(:async, :perform_if_needed)
|
|
|
|
|
|
|
|
pipeline.succeed!
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#latest_test_report_builds' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'returns pipeline builds with test report artifacts' do
|
2021-04-17 20:07:23 +05:30
|
|
|
test_build = create(:ci_build, :test_reports, pipeline: pipeline)
|
2021-02-22 17:27:13 +05:30
|
|
|
create(:ci_build, :artifacts, pipeline: pipeline, project: project)
|
|
|
|
|
|
|
|
expect(pipeline.latest_test_report_builds).to contain_exactly(test_build)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'preloads project on each build to avoid N+1 queries' do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :test_reports, pipeline: pipeline)
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
control_count = ActiveRecord::QueryRecorder.new do
|
|
|
|
pipeline.latest_test_report_builds.map(&:project).map(&:full_path)
|
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
multi_build_pipeline = create(:ci_empty_pipeline, :created)
|
2021-02-22 17:27:13 +05:30
|
|
|
create(:ci_build, :test_reports, pipeline: multi_build_pipeline, project: project)
|
|
|
|
create(:ci_build, :test_reports, pipeline: multi_build_pipeline, project: project)
|
|
|
|
|
|
|
|
expect { multi_build_pipeline.latest_test_report_builds.map(&:project).map(&:full_path) }
|
|
|
|
.not_to exceed_query_limit(control_count)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#builds_with_failed_tests' do
|
2021-04-17 20:07:23 +05:30
|
|
|
let_it_be(:pipeline) { create(:ci_pipeline, :created) }
|
|
|
|
|
2021-02-22 17:27:13 +05:30
|
|
|
it 'returns pipeline builds with test report artifacts' do
|
2021-04-17 20:07:23 +05:30
|
|
|
failed_build = create(:ci_build, :failed, :test_reports, pipeline: pipeline)
|
|
|
|
create(:ci_build, :success, :test_reports, pipeline: pipeline)
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
expect(pipeline.builds_with_failed_tests).to contain_exactly(failed_build)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'supports limiting the number of builds to fetch' do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :failed, :test_reports, pipeline: pipeline)
|
|
|
|
create(:ci_build, :failed, :test_reports, pipeline: pipeline)
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
expect(pipeline.builds_with_failed_tests(limit: 1).count).to eq(1)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'preloads project on each build to avoid N+1 queries' do
|
2021-04-17 20:07:23 +05:30
|
|
|
create(:ci_build, :failed, :test_reports, pipeline: pipeline)
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
control_count = ActiveRecord::QueryRecorder.new do
|
|
|
|
pipeline.builds_with_failed_tests.map(&:project).map(&:full_path)
|
|
|
|
end
|
|
|
|
|
2021-04-17 20:07:23 +05:30
|
|
|
multi_build_pipeline = create(:ci_empty_pipeline, :created)
|
|
|
|
create(:ci_build, :failed, :test_reports, pipeline: multi_build_pipeline)
|
|
|
|
create(:ci_build, :failed, :test_reports, pipeline: multi_build_pipeline)
|
2021-02-22 17:27:13 +05:30
|
|
|
|
|
|
|
expect { multi_build_pipeline.builds_with_failed_tests.map(&:project).map(&:full_path) }
|
|
|
|
.not_to exceed_query_limit(control_count)
|
|
|
|
end
|
|
|
|
end
|
2016-06-16 23:09:34 +05:30
|
|
|
end
|