debian-mirror-gitlab/spec/models/ci/build_spec.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

5540 lines
162 KiB
Ruby
Raw Normal View History

2019-07-07 11:18:12 +05:30
# frozen_string_literal: true
require 'spec_helper'
2020-07-28 23:09:34 +05:30
RSpec.describe Ci::Build do
2022-08-27 11:52:29 +05:30
include Ci::TemplateHelpers
include AfterNextHelpers
2020-03-13 15:44:24 +05:30
let_it_be(:user) { create(:user) }
let_it_be(:group, reload: true) { create(:group) }
let_it_be(:project, reload: true) { create(:project, :repository, group: group) }
2020-03-13 15:44:24 +05:30
let_it_be(:pipeline, reload: true) do
2017-08-17 22:00:37 +05:30
create(:ci_pipeline, project: project,
sha: project.commit.id,
ref: project.default_branch,
status: 'success')
end
2021-02-22 17:27:13 +05:30
let_it_be(:build, refind: true) { create(:ci_build, pipeline: pipeline) }
2018-03-17 18:26:18 +05:30
2017-08-17 22:00:37 +05:30
it { is_expected.to belong_to(:runner) }
it { is_expected.to belong_to(:trigger_request) }
it { is_expected.to belong_to(:erased_by) }
2019-12-21 20:55:43 +05:30
2019-10-12 21:52:04 +05:30
it { is_expected.to have_many(:needs) }
2019-12-21 20:55:43 +05:30
it { is_expected.to have_many(:sourced_pipelines) }
it { is_expected.to have_many(:job_variables) }
2020-06-23 00:09:42 +05:30
it { is_expected.to have_many(:report_results) }
2020-11-24 15:15:51 +05:30
it { is_expected.to have_many(:pages_deployments) }
2019-12-21 20:55:43 +05:30
2018-12-13 13:39:08 +05:30
it { is_expected.to have_one(:deployment) }
2019-10-12 21:52:04 +05:30
it { is_expected.to have_one(:runner_session) }
2021-10-27 15:23:28 +05:30
it { is_expected.to have_one(:trace_metadata) }
2022-01-26 12:08:38 +05:30
it { is_expected.to have_many(:terraform_state_versions).inverse_of(:build) }
2019-12-21 20:55:43 +05:30
2017-08-17 22:00:37 +05:30
it { is_expected.to validate_presence_of(:ref) }
2019-12-21 20:55:43 +05:30
2017-08-17 22:00:37 +05:30
it { is_expected.to respond_to(:has_trace?) }
it { is_expected.to respond_to(:trace) }
2021-12-11 22:18:48 +05:30
it { is_expected.to respond_to(:set_cancel_gracefully) }
it { is_expected.to respond_to(:cancel_gracefully?) }
2019-12-21 20:55:43 +05:30
2020-03-13 15:44:24 +05:30
it { is_expected.to delegate_method(:merge_request?).to(:pipeline) }
2019-07-07 11:18:12 +05:30
it { is_expected.to delegate_method(:merge_request_ref?).to(:pipeline) }
it { is_expected.to delegate_method(:legacy_detached_merge_request_pipeline?).to(:pipeline) }
2019-12-21 20:55:43 +05:30
2021-09-30 23:02:18 +05:30
shared_examples 'calling proper BuildFinishedWorker' do
2022-08-13 15:12:31 +05:30
it 'calls Ci::BuildFinishedWorker' do
expect(Ci::BuildFinishedWorker).to receive(:perform_async)
2021-09-30 23:02:18 +05:30
2022-08-13 15:12:31 +05:30
subject
2021-09-30 23:02:18 +05:30
end
end
2018-03-17 18:26:18 +05:30
describe 'associations' do
it 'has a bidirectional relationship with projects' do
expect(described_class.reflect_on_association(:project).has_inverse?).to eq(:builds)
expect(Project.reflect_on_association(:builds).has_inverse?).to eq(:project)
end
end
describe 'callbacks' do
context 'when running after_create callback' do
2022-08-27 11:52:29 +05:30
it 'executes hooks' do
expect_next(described_class).to receive(:execute_hooks)
2018-03-17 18:26:18 +05:30
create(:ci_build)
end
end
end
2018-11-08 19:23:39 +05:30
describe 'status' do
context 'when transitioning to any state from running' do
it 'removes runner_session' do
%w(success drop cancel).each do |event|
build = FactoryBot.create(:ci_build, :running, :with_runner_session, pipeline: pipeline)
build.fire_events!(event)
expect(build.reload.runner_session).to be_nil
end
end
end
end
2022-08-27 11:52:29 +05:30
it_behaves_like 'has ID tokens', :ci_build
2017-09-10 17:25:29 +05:30
describe '.manual_actions' do
let!(:manual_but_created) { create(:ci_build, :manual, status: :created, pipeline: pipeline) }
let!(:manual_but_succeeded) { create(:ci_build, :manual, status: :success, pipeline: pipeline) }
let!(:manual_action) { create(:ci_build, :manual, pipeline: pipeline) }
subject { described_class.manual_actions }
it { is_expected.to include(manual_action) }
it { is_expected.to include(manual_but_succeeded) }
it { is_expected.not_to include(manual_but_created) }
end
2018-03-17 18:26:18 +05:30
describe '.ref_protected' do
subject { described_class.ref_protected }
context 'when protected is true' do
let!(:job) { create(:ci_build, :protected) }
it { is_expected.to include(job) }
end
context 'when protected is false' do
let!(:job) { create(:ci_build) }
it { is_expected.not_to include(job) }
end
context 'when protected is nil' do
let!(:job) { create(:ci_build) }
before do
job.update_attribute(:protected, nil)
end
it { is_expected.not_to include(job) }
end
end
2020-05-24 23:13:21 +05:30
describe '.with_downloadable_artifacts' do
subject { described_class.with_downloadable_artifacts }
2018-03-27 19:54:05 +05:30
2020-05-24 23:13:21 +05:30
context 'when job does not have a downloadable artifact' do
2018-03-27 19:54:05 +05:30
let!(:job) { create(:ci_build) }
it 'does not return the job' do
is_expected.not_to include(job)
end
end
2020-05-24 23:13:21 +05:30
::Ci::JobArtifact::DOWNLOADABLE_TYPES.each do |type|
context "when job has a #{type} artifact" do
it 'returns the job' do
job = create(:ci_build)
create(
:ci_job_artifact,
file_format: ::Ci::JobArtifact::TYPE_AND_FORMAT_PAIRS[type.to_sym],
file_type: type,
job: job
)
2018-03-27 19:54:05 +05:30
2020-05-24 23:13:21 +05:30
is_expected.to include(job)
end
2018-03-27 19:54:05 +05:30
end
end
2020-05-24 23:13:21 +05:30
context 'when job has a non-downloadable artifact' do
2018-03-27 19:54:05 +05:30
let!(:job) { create(:ci_build, :trace_artifact) }
it 'does not return the job' do
is_expected.not_to include(job)
end
end
end
2022-11-25 23:54:43 +05:30
describe '.with_erasable_artifacts' do
subject { described_class.with_erasable_artifacts }
context 'when job does not have any artifacts' do
let!(:job) { create(:ci_build) }
it 'does not return the job' do
is_expected.not_to include(job)
end
end
::Ci::JobArtifact.erasable_file_types.each do |type|
context "when job has a #{type} artifact" do
it 'returns the job' do
job = create(:ci_build)
create(
:ci_job_artifact,
file_format: ::Ci::JobArtifact::TYPE_AND_FORMAT_PAIRS[type.to_sym],
file_type: type,
job: job
)
is_expected.to include(job)
end
end
end
context 'when job has a non-erasable artifact' do
let!(:job) { create(:ci_build, :trace_artifact) }
it 'does not return the job' do
is_expected.not_to include(job)
end
end
end
2018-11-08 19:23:39 +05:30
describe '.with_live_trace' do
subject { described_class.with_live_trace }
context 'when build has live trace' do
let!(:build) { create(:ci_build, :success, :trace_live) }
it 'selects the build' do
is_expected.to eq([build])
end
end
context 'when build does not have live trace' do
let!(:build) { create(:ci_build, :success, :trace_artifact) }
it 'does not select the build' do
is_expected.to be_empty
end
end
end
2019-12-04 20:38:33 +05:30
describe '.with_stale_live_trace' do
subject { described_class.with_stale_live_trace }
context 'when build has a stale live trace' do
let!(:build) { create(:ci_build, :success, :trace_live, finished_at: 1.day.ago) }
it 'selects the build' do
is_expected.to eq([build])
end
end
context 'when build does not have a stale live trace' do
let!(:build) { create(:ci_build, :success, :trace_live, finished_at: 1.hour.ago) }
it 'does not select the build' do
is_expected.to be_empty
end
end
end
2021-12-11 22:18:48 +05:30
describe '.license_management_jobs' do
subject { described_class.license_management_jobs }
let!(:management_build) { create(:ci_build, :success, name: :license_management) }
let!(:scanning_build) { create(:ci_build, :success, name: :license_scanning) }
let!(:another_build) { create(:ci_build, :success, name: :another_type) }
it 'returns license_scanning jobs' do
is_expected.to include(scanning_build)
end
it 'returns license_management jobs' do
is_expected.to include(management_build)
end
it 'doesnt return filtered out jobs' do
is_expected.not_to include(another_build)
end
end
2019-12-04 20:38:33 +05:30
describe '.finished_before' do
subject { described_class.finished_before(date) }
let(:date) { 1.hour.ago }
context 'when build has finished one day ago' do
let!(:build) { create(:ci_build, :success, finished_at: 1.day.ago) }
it 'selects the build' do
is_expected.to eq([build])
end
end
context 'when build has finished 30 minutes ago' do
let!(:build) { create(:ci_build, :success, finished_at: 30.minutes.ago) }
it 'returns an empty array' do
is_expected.to be_empty
end
end
context 'when build is still running' do
let!(:build) { create(:ci_build, :running) }
it 'returns an empty array' do
is_expected.to be_empty
end
end
end
2019-12-26 22:10:19 +05:30
describe '.with_exposed_artifacts' do
subject { described_class.with_exposed_artifacts }
let!(:job1) { create(:ci_build) }
let!(:job2) { create(:ci_build, options: options) }
let!(:job3) { create(:ci_build) }
context 'when some jobs have exposed artifacs and some not' do
let(:options) { { artifacts: { expose_as: 'test', paths: ['test'] } } }
before do
job1.ensure_metadata.update!(has_exposed_artifacts: nil)
job3.ensure_metadata.update!(has_exposed_artifacts: false)
end
it 'selects only the jobs with exposed artifacts' do
is_expected.to eq([job2])
end
end
context 'when job does not expose artifacts' do
let(:options) { nil }
it 'returns an empty array' do
is_expected.to be_empty
end
end
end
2022-07-23 23:45:48 +05:30
describe '.with_artifacts' do
subject(:builds) { described_class.with_artifacts(artifact_scope) }
2018-11-18 11:00:15 +05:30
2022-07-23 23:45:48 +05:30
let(:artifact_scope) { Ci::JobArtifact.where(file_type: 'archive') }
2018-11-18 11:00:15 +05:30
2022-11-25 23:54:43 +05:30
let!(:build_1) { create(:ci_build, :artifacts, pipeline: pipeline) }
let!(:build_2) { create(:ci_build, :codequality_reports, pipeline: pipeline) }
let!(:build_3) { create(:ci_build, :test_reports, pipeline: pipeline) }
let!(:build_4) { create(:ci_build, :artifacts, pipeline: pipeline) }
2018-11-18 11:00:15 +05:30
2022-07-23 23:45:48 +05:30
it 'returns artifacts matching the given scope' do
expect(builds).to contain_exactly(build_1, build_4)
2018-11-18 11:00:15 +05:30
end
2022-07-23 23:45:48 +05:30
context 'when there are multiple builds containing artifacts' do
before do
create_list(:ci_build, 5, :success, :test_reports)
end
2018-11-18 11:00:15 +05:30
it 'does not execute a query for selecting job artifact one by one' do
recorded = ActiveRecord::QueryRecorder.new do
2022-07-23 23:45:48 +05:30
builds.each do |build|
2018-12-05 23:21:45 +05:30
build.job_artifacts.map { |a| a.file.exists? }
2018-11-18 11:00:15 +05:30
end
end
expect(recorded.count).to eq(2)
end
end
end
2019-10-12 21:52:04 +05:30
describe '.with_needs' do
let!(:build) { create(:ci_build) }
let!(:build_b) { create(:ci_build) }
let!(:build_need_a) { create(:ci_build_need, build: build) }
let!(:build_need_b) { create(:ci_build_need, build: build_b) }
context 'when passing build name' do
subject { described_class.with_needs(build_need_a.name) }
it { is_expected.to contain_exactly(build) }
end
context 'when not passing any build name' do
subject { described_class.with_needs }
it { is_expected.to contain_exactly(build, build_b) }
end
context 'when not matching build name' do
subject { described_class.with_needs('undefined') }
it { is_expected.to be_empty }
end
end
describe '.without_needs' do
subject { described_class.without_needs }
context 'when no build_need is created' do
it { is_expected.to contain_exactly(build) }
end
context 'when a build_need is created' do
let!(:need_a) { create(:ci_build_need, build: build) }
it { is_expected.to be_empty }
end
end
2021-09-04 01:27:46 +05:30
describe '#stick_build_if_status_changed' do
2021-11-18 22:05:49 +05:30
it 'sticks the build if the status changed' do
2021-09-04 01:27:46 +05:30
job = create(:ci_build, :pending)
2021-12-11 22:18:48 +05:30
expect(described_class.sticking).to receive(:stick)
2021-09-04 01:27:46 +05:30
.with(:build, job.id)
job.update!(status: :running)
end
end
2019-07-07 11:18:12 +05:30
describe '#enqueue' do
let(:build) { create(:ci_build, :created) }
before do
allow(build).to receive(:any_unmet_prerequisites?).and_return(has_prerequisites)
allow(Ci::PrepareBuildService).to receive(:perform_async)
end
context 'build has unmet prerequisites' do
let(:has_prerequisites) { true }
it 'transitions to preparing' do
2021-09-04 01:27:46 +05:30
build.enqueue
2019-07-07 11:18:12 +05:30
expect(build).to be_preparing
end
2021-09-04 01:27:46 +05:30
it 'does not push build to the queue' do
build.enqueue
expect(build.queuing_entry).not_to be_present
end
2019-07-07 11:18:12 +05:30
end
context 'build has no prerequisites' do
let(:has_prerequisites) { false }
it 'transitions to pending' do
2021-09-04 01:27:46 +05:30
build.enqueue
2019-07-07 11:18:12 +05:30
expect(build).to be_pending
end
2021-09-04 01:27:46 +05:30
it 'pushes build to a queue' do
build.enqueue
expect(build.queuing_entry).to be_present
end
context 'when build status transition fails' do
before do
::Ci::Build.find(build.id).update_column(:lock_version, 100)
end
it 'does not push build to a queue' do
expect { build.enqueue! }
.to raise_error(ActiveRecord::StaleObjectError)
expect(build.queuing_entry).not_to be_present
end
end
context 'when there is a queuing entry already present' do
before do
2021-09-30 23:02:18 +05:30
create(:ci_pending_build, build: build, project: build.project)
2021-09-04 01:27:46 +05:30
end
it 'does not raise an error' do
expect { build.enqueue! }.not_to raise_error
expect(build.reload.queuing_entry).to be_present
end
end
context 'when both failure scenario happen at the same time' do
before do
::Ci::Build.find(build.id).update_column(:lock_version, 100)
2021-09-30 23:02:18 +05:30
create(:ci_pending_build, build: build, project: build.project)
2021-09-04 01:27:46 +05:30
end
it 'raises stale object error exception' do
expect { build.enqueue! }
.to raise_error(ActiveRecord::StaleObjectError)
end
end
2019-07-07 11:18:12 +05:30
end
end
2020-03-13 15:44:24 +05:30
describe '#enqueue_preparing' do
let(:build) { create(:ci_build, :preparing) }
before do
allow(build).to receive(:any_unmet_prerequisites?).and_return(has_unmet_prerequisites)
end
context 'build completed prerequisites' do
let(:has_unmet_prerequisites) { false }
it 'transitions to pending' do
2021-09-04 01:27:46 +05:30
build.enqueue_preparing
2020-03-13 15:44:24 +05:30
expect(build).to be_pending
2021-09-04 01:27:46 +05:30
expect(build.queuing_entry).to be_present
2020-03-13 15:44:24 +05:30
end
end
context 'build did not complete prerequisites' do
let(:has_unmet_prerequisites) { true }
it 'remains in preparing' do
2021-09-04 01:27:46 +05:30
build.enqueue_preparing
2020-03-13 15:44:24 +05:30
expect(build).to be_preparing
2021-09-04 01:27:46 +05:30
expect(build.queuing_entry).not_to be_present
2020-03-13 15:44:24 +05:30
end
end
end
2017-08-17 22:00:37 +05:30
describe '#actionize' do
context 'when build is a created' do
before do
build.update_column(:status, :created)
end
it 'makes build a manual action' do
expect(build.actionize).to be true
expect(build.reload).to be_manual
end
end
context 'when build is not created' do
before do
build.update_column(:status, :pending)
end
it 'does not change build status' do
expect(build.actionize).to be false
expect(build.reload).to be_pending
end
end
end
2021-09-04 01:27:46 +05:30
describe '#run' do
context 'when build has been just created' do
let(:build) { create(:ci_build, :created) }
it 'creates queuing entry and then removes it' do
build.enqueue!
expect(build.queuing_entry).to be_present
build.run!
expect(build.reload.queuing_entry).not_to be_present
end
end
context 'when build status transition fails' do
let(:build) { create(:ci_build, :pending) }
before do
2021-09-30 23:02:18 +05:30
create(:ci_pending_build, build: build, project: build.project)
2021-09-04 01:27:46 +05:30
::Ci::Build.find(build.id).update_column(:lock_version, 100)
end
it 'does not remove build from a queue' do
expect { build.run! }
.to raise_error(ActiveRecord::StaleObjectError)
expect(build.queuing_entry).to be_present
end
end
context 'when build has been picked by a shared runner' do
let(:build) { create(:ci_build, :pending) }
it 'creates runtime metadata entry' do
build.runner = create(:ci_runner, :instance_type)
build.run!
expect(build.reload.runtime_metadata).to be_present
end
end
end
describe '#drop' do
context 'when has a runtime tracking entry' do
let(:build) { create(:ci_build, :pending) }
it 'removes runtime tracking entry' do
build.runner = create(:ci_runner, :instance_type)
build.run!
expect(build.reload.runtime_metadata).to be_present
build.drop!
expect(build.reload.runtime_metadata).not_to be_present
end
end
2022-03-02 08:16:31 +05:30
context 'when a failure reason is provided' do
context 'when a failure reason is a symbol' do
it 'correctly sets a failure reason' do
build.drop!(:script_failure)
expect(build.failure_reason).to eq 'script_failure'
end
end
context 'when a failure reason is an object' do
it 'correctly sets a failure reason' do
reason = ::Gitlab::Ci::Build::Status::Reason.new(build, :script_failure)
build.drop!(reason)
expect(build.failure_reason).to eq 'script_failure'
end
end
end
2021-09-04 01:27:46 +05:30
end
2022-10-11 01:57:18 +05:30
describe '#prevent_rollback_deployment?' do
subject { build.prevent_rollback_deployment? }
let(:build) { create(:ci_build, :created, :with_deployment, project: project, environment: 'production') }
context 'when build has no environment' do
let(:build) { create(:ci_build, :created, project: project, environment: nil) }
it { expect(subject).to be_falsey }
end
context 'when project has forward deployment disabled' do
before do
project.ci_cd_settings.update!(forward_deployment_enabled: false)
end
it { expect(subject).to be_falsey }
end
context 'when deployment cannot rollback' do
before do
expect(build.deployment).to receive(:older_than_last_successful_deployment?).and_return(false)
end
it { expect(subject).to be_falsey }
end
context 'when build can prevent rollback deployment' do
before do
expect(build.deployment).to receive(:older_than_last_successful_deployment?).and_return(true)
end
it { expect(subject).to be_truthy }
end
end
2018-12-05 23:21:45 +05:30
describe '#schedulable?' do
subject { build.schedulable? }
context 'when build is schedulable' do
let(:build) { create(:ci_build, :created, :schedulable, project: project) }
it { expect(subject).to be_truthy }
end
context 'when build is not schedulable' do
let(:build) { create(:ci_build, :created, project: project) }
it { expect(subject).to be_falsy }
end
end
describe '#schedule' do
subject { build.schedule }
before do
project.add_developer(user)
end
let(:build) { create(:ci_build, :created, :schedulable, user: user, project: project) }
it 'transits to scheduled' do
allow(Ci::BuildScheduleWorker).to receive(:perform_at)
subject
expect(build).to be_scheduled
end
it 'updates scheduled_at column' do
allow(Ci::BuildScheduleWorker).to receive(:perform_at)
subject
expect(build.scheduled_at).not_to be_nil
end
it 'schedules BuildScheduleWorker at the right time' do
2020-11-24 15:15:51 +05:30
freeze_time do
2018-12-05 23:21:45 +05:30
expect(Ci::BuildScheduleWorker)
2018-12-13 13:39:08 +05:30
.to receive(:perform_at).with(be_like_time(1.minute.since), build.id)
2018-12-05 23:21:45 +05:30
subject
end
end
end
describe '#unschedule' do
subject { build.unschedule }
context 'when build is scheduled' do
let(:build) { create(:ci_build, :scheduled, pipeline: pipeline) }
it 'cleans scheduled_at column' do
subject
expect(build.scheduled_at).to be_nil
end
it 'transits to manual' do
subject
expect(build).to be_manual
end
end
context 'when build is not scheduled' do
let(:build) { create(:ci_build, :created, pipeline: pipeline) }
it 'does not transit status' do
subject
expect(build).to be_created
end
end
end
describe '#options_scheduled_at' do
subject { build.options_scheduled_at }
let(:build) { build_stubbed(:ci_build, options: option) }
context 'when start_in is 1 day' do
let(:option) { { start_in: '1 day' } }
it 'returns date after 1 day' do
2020-11-24 15:15:51 +05:30
freeze_time do
2018-12-05 23:21:45 +05:30
is_expected.to eq(1.day.since)
end
end
end
context 'when start_in is 1 week' do
let(:option) { { start_in: '1 week' } }
it 'returns date after 1 week' do
2020-11-24 15:15:51 +05:30
freeze_time do
2018-12-05 23:21:45 +05:30
is_expected.to eq(1.week.since)
end
end
end
end
describe '#enqueue_scheduled' do
subject { build.enqueue_scheduled }
context 'when build is scheduled and the right time has not come yet' do
let(:build) { create(:ci_build, :scheduled, pipeline: pipeline) }
it 'does not transits the status' do
subject
expect(build).to be_scheduled
end
end
context 'when build is scheduled and the right time has already come' do
let(:build) { create(:ci_build, :expired_scheduled, pipeline: pipeline) }
it 'cleans scheduled_at column' do
subject
expect(build.scheduled_at).to be_nil
end
it 'transits to pending' do
subject
expect(build).to be_pending
end
2019-07-07 11:18:12 +05:30
context 'build has unmet prerequisites' do
before do
allow(build).to receive(:prerequisites).and_return([double])
end
it 'transits to preparing' do
subject
expect(build).to be_preparing
end
end
2018-12-05 23:21:45 +05:30
end
end
2017-08-17 22:00:37 +05:30
describe '#any_runners_online?' do
subject { build.any_runners_online? }
context 'when no runners' do
it { is_expected.to be_falsey }
end
2022-07-16 23:28:13 +05:30
context 'when there is a runner' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :project, projects: [build.project]) }
2017-08-17 22:00:37 +05:30
before do
2020-11-24 15:15:51 +05:30
runner.update!(contacted_at: 1.second.ago)
2017-08-17 22:00:37 +05:30
end
it { is_expected.to be_truthy }
2022-07-16 23:28:13 +05:30
context 'that is inactive' do
before do
runner.update!(active: false)
end
it { is_expected.to be_falsey }
2017-08-17 22:00:37 +05:30
end
2022-07-16 23:28:13 +05:30
context 'that is not online' do
before do
runner.update!(contacted_at: nil)
end
it { is_expected.to be_falsey }
2017-08-17 22:00:37 +05:30
end
2022-07-16 23:28:13 +05:30
context 'that cannot handle build' do
before do
expect_any_instance_of(Gitlab::Ci::Matching::RunnerMatcher).to receive(:matches?).with(build.build_matcher).and_return(false)
end
it { is_expected.to be_falsey }
2017-08-17 22:00:37 +05:30
end
end
2021-04-29 21:17:54 +05:30
2021-09-04 01:27:46 +05:30
it 'caches the result in Redis' do
expect(Rails.cache).to receive(:fetch).with(['has-online-runners', build.id], expires_in: 1.minute)
2021-04-29 21:17:54 +05:30
2021-09-04 01:27:46 +05:30
build.any_runners_online?
2021-04-29 21:17:54 +05:30
end
end
describe '#any_runners_available?' do
subject { build.any_runners_available? }
context 'when no runners' do
it { is_expected.to be_falsey }
end
context 'when there are runners' do
let!(:runner) { create(:ci_runner, :project, projects: [build.project]) }
it { is_expected.to be_truthy }
end
2021-09-04 01:27:46 +05:30
it 'caches the result in Redis' do
expect(Rails.cache).to receive(:fetch).with(['has-available-runners', build.project.id], expires_in: 1.minute)
2021-04-29 21:17:54 +05:30
2021-09-04 01:27:46 +05:30
build.any_runners_available?
2021-04-29 21:17:54 +05:30
end
2017-08-17 22:00:37 +05:30
end
describe '#artifacts?' do
subject { build.artifacts? }
2018-03-17 18:26:18 +05:30
context 'when new artifacts are used' do
context 'artifacts archive does not exist' do
let(:build) { create(:ci_build) }
it { is_expected.to be_falsy }
2017-08-17 22:00:37 +05:30
end
2018-03-17 18:26:18 +05:30
context 'artifacts archive exists' do
let(:build) { create(:ci_build, :artifacts) }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
it { is_expected.to be_truthy }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
context 'is expired' do
let(:build) { create(:ci_build, :artifacts, :expired) }
it { is_expected.to be_falsy }
2017-09-10 17:25:29 +05:30
end
2018-03-17 18:26:18 +05:30
end
end
2018-05-09 12:01:36 +05:30
end
2018-03-17 18:26:18 +05:30
2020-11-24 15:15:51 +05:30
describe '#locked_artifacts?' do
subject(:locked_artifacts) { build.locked_artifacts? }
context 'when pipeline is artifacts_locked' do
before do
build.pipeline.artifacts_locked!
end
context 'artifacts archive does not exist' do
let(:build) { create(:ci_build) }
it { is_expected.to be_falsy }
end
context 'artifacts archive exists' do
let(:build) { create(:ci_build, :artifacts) }
it { is_expected.to be_truthy }
end
end
context 'when pipeline is unlocked' do
before do
build.pipeline.unlocked!
end
context 'artifacts archive does not exist' do
let(:build) { create(:ci_build) }
it { is_expected.to be_falsy }
end
context 'artifacts archive exists' do
let(:build) { create(:ci_build, :artifacts) }
it { is_expected.to be_falsy }
end
end
end
2020-10-24 23:57:45 +05:30
describe '#available_artifacts?' do
let(:build) { create(:ci_build) }
subject { build.available_artifacts? }
context 'when artifacts are not expired' do
before do
build.artifacts_expire_at = Date.tomorrow
end
context 'when artifacts exist' do
before do
create(:ci_job_artifact, :archive, job: build)
end
it { is_expected.to be_truthy }
end
context 'when artifacts do not exist' do
it { is_expected.to be_falsey }
end
end
context 'when artifacts are expired' do
before do
build.artifacts_expire_at = Date.yesterday
end
context 'when artifacts are not locked' do
before do
build.pipeline.locked = :unlocked
end
it { is_expected.to be_falsey }
end
context 'when artifacts are locked' do
before do
build.pipeline.locked = :artifacts_locked
end
context 'when artifacts exist' do
before do
create(:ci_job_artifact, :archive, job: build)
end
it { is_expected.to be_truthy }
end
context 'when artifacts do not exist' do
it { is_expected.to be_falsey }
end
end
end
end
2018-05-09 12:01:36 +05:30
describe '#browsable_artifacts?' do
subject { build.browsable_artifacts? }
2018-03-17 18:26:18 +05:30
2018-05-09 12:01:36 +05:30
context 'artifacts metadata does exists' do
let(:build) { create(:ci_build, :artifacts) }
it { is_expected.to be_truthy }
2017-08-17 22:00:37 +05:30
end
end
2021-03-08 18:12:59 +05:30
describe '#artifacts_public?' do
subject { build.artifacts_public? }
context 'artifacts with defaults' do
let(:build) { create(:ci_build, :artifacts) }
it { is_expected.to be_truthy }
end
context 'non public artifacts' do
let(:build) { create(:ci_build, :artifacts, :non_public_artifacts) }
it { is_expected.to be_falsey }
end
end
2017-08-17 22:00:37 +05:30
describe '#artifacts_expired?' do
subject { build.artifacts_expired? }
context 'is expired' do
2017-09-10 17:25:29 +05:30
before do
2020-11-24 15:15:51 +05:30
build.update!(artifacts_expire_at: Time.current - 7.days)
2017-09-10 17:25:29 +05:30
end
2017-08-17 22:00:37 +05:30
it { is_expected.to be_truthy }
end
context 'is not expired' do
2017-09-10 17:25:29 +05:30
before do
2020-11-24 15:15:51 +05:30
build.update!(artifacts_expire_at: Time.current + 7.days)
2017-09-10 17:25:29 +05:30
end
2017-08-17 22:00:37 +05:30
it { is_expected.to be_falsey }
end
end
describe '#artifacts_metadata?' do
subject { build.artifacts_metadata? }
2019-12-21 20:55:43 +05:30
2017-08-17 22:00:37 +05:30
context 'artifacts metadata does not exist' do
it { is_expected.to be_falsy }
end
context 'artifacts archive is a zip file and metadata exists' do
let(:build) { create(:ci_build, :artifacts) }
2020-03-13 15:44:24 +05:30
2017-08-17 22:00:37 +05:30
it { is_expected.to be_truthy }
end
end
describe '#artifacts_expire_in' do
subject { build.artifacts_expire_in }
2019-12-21 20:55:43 +05:30
2017-08-17 22:00:37 +05:30
it { is_expected.to be_nil }
context 'when artifacts_expire_at is specified' do
2020-06-23 00:09:42 +05:30
let(:expire_at) { Time.current + 7.days }
2017-08-17 22:00:37 +05:30
2017-09-10 17:25:29 +05:30
before do
build.artifacts_expire_at = expire_at
end
2017-08-17 22:00:37 +05:30
2020-06-23 00:09:42 +05:30
it { is_expected.to be_within(5).of(expire_at - Time.current) }
2017-08-17 22:00:37 +05:30
end
end
describe '#artifacts_expire_in=' do
subject { build.artifacts_expire_in }
it 'when assigning valid duration' do
build.artifacts_expire_in = '7 days'
is_expected.to be_within(10).of(7.days.to_i)
end
it 'when assigning invalid duration' do
expect { build.artifacts_expire_in = '7 elephants' }.to raise_error(ChronicDuration::DurationParseError)
is_expected.to be_nil
end
it 'when resetting value' do
build.artifacts_expire_in = nil
is_expected.to be_nil
end
it 'when setting to 0' do
build.artifacts_expire_in = '0'
is_expected.to be_nil
end
end
describe '#commit' do
it 'returns commit pipeline has been created for' do
expect(build.commit).to eq project.commit
end
end
2018-03-17 18:26:18 +05:30
describe '#cache' do
2021-04-17 20:07:23 +05:30
let(:options) do
{ cache: [{ key: "key", paths: ["public"], policy: "pull-push" }] }
end
2018-03-17 18:26:18 +05:30
subject { build.cache }
context 'when build has cache' do
before do
allow(build).to receive(:options).and_return(options)
end
2021-04-17 20:07:23 +05:30
context 'when build has multiple caches' do
let(:options) do
{ cache: [
{ key: "key", paths: ["public"], policy: "pull-push" },
{ key: "key2", paths: ["public"], policy: "pull-push" }
] }
end
before do
allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(1)
end
2022-05-03 16:02:30 +05:30
it { is_expected.to match([a_hash_including(key: 'key-1-non_protected'), a_hash_including(key: 'key2-1-non_protected')]) }
context 'when pipeline is on a protected ref' do
before do
allow(build.pipeline).to receive(:protected_ref?).and_return(true)
end
it do
is_expected.to all(a_hash_including(key: a_string_matching(/-protected$/)))
end
end
context 'when pipeline is not on a protected ref' do
before do
allow(build.pipeline).to receive(:protected_ref?).and_return(false)
end
it do
is_expected.to all(a_hash_including(key: a_string_matching(/-non_protected$/)))
end
end
2022-06-21 17:19:12 +05:30
context 'when separated caches are disabled' do
before do
allow_any_instance_of(Project).to receive(:ci_separated_caches).and_return(false)
end
context 'running on protected ref' do
before do
allow(build.pipeline).to receive(:protected_ref?).and_return(true)
end
it 'is expected to have no type suffix' do
is_expected.to match([a_hash_including(key: 'key-1'), a_hash_including(key: 'key2-1')])
end
end
context 'running on not protected ref' do
before do
allow(build.pipeline).to receive(:protected_ref?).and_return(false)
end
it 'is expected to have no type suffix' do
is_expected.to match([a_hash_including(key: 'key-1'), a_hash_including(key: 'key2-1')])
end
end
end
2021-04-17 20:07:23 +05:30
end
2018-03-17 18:26:18 +05:30
context 'when project has jobs_cache_index' do
before do
allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(1)
end
2022-05-03 16:02:30 +05:30
it { is_expected.to be_an(Array).and all(include(key: a_string_matching(/^key-1-(?>protected|non_protected)/))) }
2018-03-17 18:26:18 +05:30
end
context 'when project does not have jobs_cache_index' do
before do
allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(nil)
end
2022-05-03 16:02:30 +05:30
it do
is_expected.to eq(options[:cache].map { |entry| entry.merge(key: "#{entry[:key]}-non_protected") })
end
2018-03-17 18:26:18 +05:30
end
end
context 'when build does not have cache' do
before do
allow(build).to receive(:options).and_return({})
end
2021-04-17 20:07:23 +05:30
it { is_expected.to be_empty }
2018-03-17 18:26:18 +05:30
end
end
describe '#triggered_by?' do
subject { build.triggered_by?(user) }
context 'when user is owner' do
let(:build) { create(:ci_build, pipeline: pipeline, user: user) }
it { is_expected.to be_truthy }
end
context 'when user is not owner' do
let(:another_user) { create(:user) }
let(:build) { create(:ci_build, pipeline: pipeline, user: another_user) }
it { is_expected.to be_falsy }
end
end
2017-08-17 22:00:37 +05:30
describe '#detailed_status' do
it 'returns a detailed status' do
expect(build.detailed_status(user))
.to be_a Gitlab::Ci::Status::Build::Cancelable
end
end
describe '#update_coverage' do
context "regarding coverage_regex's value," do
before do
build.coverage_regex = '\(\d+.\d+\%\) covered'
build.trace.set('Coverage 1033 / 1051 LOC (98.29%) covered')
end
it "saves the correct extracted coverage value" do
expect(build.update_coverage).to be(true)
expect(build.coverage).to eq(98.29)
end
end
end
describe '#trace' do
2017-08-17 22:00:37 +05:30
subject { build.trace }
it { is_expected.to be_a(Gitlab::Ci::Trace) }
end
describe '#has_trace?' do
subject { build.has_trace? }
it "expect to call exist? method" do
expect_any_instance_of(Gitlab::Ci::Trace).to receive(:exist?)
.and_return(true)
is_expected.to be(true)
end
end
2019-10-12 21:52:04 +05:30
describe '#has_live_trace?' do
subject { build.has_live_trace? }
let(:build) { create(:ci_build, :trace_live) }
it { is_expected.to be_truthy }
context 'when build does not have live trace' do
let(:build) { create(:ci_build) }
it { is_expected.to be_falsy }
end
end
describe '#has_archived_trace?' do
subject { build.has_archived_trace? }
let(:build) { create(:ci_build, :trace_artifact) }
it { is_expected.to be_truthy }
context 'when build does not have archived trace' do
let(:build) { create(:ci_build) }
it { is_expected.to be_falsy }
end
end
2018-12-05 23:21:45 +05:30
describe '#has_job_artifacts?' do
subject { build.has_job_artifacts? }
2018-11-18 11:00:15 +05:30
2018-12-05 23:21:45 +05:30
context 'when build has a job artifact' do
let(:build) { create(:ci_build, :artifacts) }
2018-11-18 11:00:15 +05:30
it { is_expected.to be_truthy }
end
end
2020-06-23 00:09:42 +05:30
describe '#has_test_reports?' do
subject { build.has_test_reports? }
context 'when build has a test report' do
let(:build) { create(:ci_build, :test_reports) }
it { is_expected.to be_truthy }
end
context 'when build does not have a test report' do
let(:build) { create(:ci_build) }
it { is_expected.to be_falsey }
end
end
2017-08-17 22:00:37 +05:30
describe '#hide_secrets' do
2020-11-24 15:15:51 +05:30
let(:metrics) { spy('metrics') }
2017-08-17 22:00:37 +05:30
let(:subject) { build.hide_secrets(data) }
context 'hide runners token' do
2022-08-27 11:52:29 +05:30
let(:data) { "new #{project.runners_token} data" }
2017-08-17 22:00:37 +05:30
2019-02-15 15:39:39 +05:30
it { is_expected.to match(/^new x+ data$/) }
2020-11-24 15:15:51 +05:30
it 'increments trace mutation metric' do
build.hide_secrets(data, metrics)
expect(metrics)
.to have_received(:increment_trace_operation)
.with(operation: :mutated)
end
2019-01-03 12:48:30 +05:30
end
context 'hide build token' do
2022-08-27 11:52:29 +05:30
let(:data) { "new #{build.token} data" }
2019-01-03 12:48:30 +05:30
2019-02-15 15:39:39 +05:30
it { is_expected.to match(/^new x+ data$/) }
2020-11-24 15:15:51 +05:30
it 'increments trace mutation metric' do
build.hide_secrets(data, metrics)
expect(metrics)
.to have_received(:increment_trace_operation)
.with(operation: :mutated)
end
end
context 'when build does not include secrets' do
let(:data) { 'my build log' }
it 'does not mutate trace' do
trace = build.hide_secrets(data)
expect(trace).to eq data
end
it 'does not increment trace mutation metric' do
build.hide_secrets(data, metrics)
expect(metrics)
.not_to have_received(:increment_trace_operation)
.with(operation: :mutated)
end
2017-08-17 22:00:37 +05:30
end
end
2022-08-27 11:52:29 +05:30
describe 'state transition metrics' do
using RSpec::Parameterized::TableSyntax
subject { build.send(event) }
2022-10-11 01:57:18 +05:30
where(:state, :report_count, :trait) do
:success! | 1 | :sast
:cancel! | 1 | :sast
:drop! | 2 | :multiple_report_artifacts
:success! | 0 | :allowed_to_fail
:skip! | 0 | :pending
2022-08-27 11:52:29 +05:30
end
with_them do
let(:build) { create(:ci_build, trait, project: project, pipeline: pipeline) }
let(:event) { state }
context "when transitioning to #{params[:state]}" do
before do
allow(Gitlab).to receive(:com?).and_return(true)
end
it 'increments build_completed_report_type metric' do
expect(
::Gitlab::Ci::Artifacts::Metrics
).to receive(
:build_completed_report_type_counter
).exactly(report_count).times.and_call_original
subject
end
end
end
end
2021-12-11 22:18:48 +05:30
describe 'state transition as a deployable' do
2021-04-29 21:17:54 +05:30
subject { build.send(event) }
2020-03-13 15:44:24 +05:30
let!(:build) { create(:ci_build, :with_deployment, :start_review_app, project: project, pipeline: pipeline) }
2018-12-13 13:39:08 +05:30
let(:deployment) { build.deployment }
let(:environment) { deployment.environment }
2019-07-31 22:56:46 +05:30
before do
2021-01-03 14:25:43 +05:30
allow(Deployments::LinkMergeRequestWorker).to receive(:perform_async)
2022-08-13 15:12:31 +05:30
allow(Deployments::HooksWorker).to receive(:perform_async)
2019-07-31 22:56:46 +05:30
end
2018-12-13 13:39:08 +05:30
it 'has deployments record with created status' do
expect(deployment).to be_created
expect(environment.name).to eq('review/master')
end
2021-04-29 21:17:54 +05:30
shared_examples_for 'avoid deadlock' do
it 'executes UPDATE in the right order' do
2021-11-11 11:23:49 +05:30
recorded = with_cross_database_modification_prevented do
ActiveRecord::QueryRecorder.new { subject }
end
2021-04-29 21:17:54 +05:30
index_for_build = recorded.log.index { |l| l.include?("UPDATE \"ci_builds\"") }
index_for_deployment = recorded.log.index { |l| l.include?("UPDATE \"deployments\"") }
expect(index_for_build).to be < index_for_deployment
2018-12-13 13:39:08 +05:30
end
2021-04-29 21:17:54 +05:30
end
context 'when transits to running' do
let(:event) { :run! }
it_behaves_like 'avoid deadlock'
2018-12-13 13:39:08 +05:30
it 'transits deployment status to running' do
2021-11-11 11:23:49 +05:30
with_cross_database_modification_prevented do
subject
end
2021-04-29 21:17:54 +05:30
2018-12-13 13:39:08 +05:30
expect(deployment).to be_running
end
2021-12-11 22:18:48 +05:30
context 'when deployment is already running state' do
before do
build.deployment.success!
end
it 'does not change deployment status and tracks an error' do
expect(Gitlab::ErrorTracking)
.to receive(:track_exception).with(
instance_of(Deployment::StatusSyncError), deployment_id: deployment.id, build_id: build.id)
with_cross_database_modification_prevented do
expect { subject }.not_to change { deployment.reload.status }
end
end
end
2018-12-13 13:39:08 +05:30
end
context 'when transits to success' do
2021-04-29 21:17:54 +05:30
let(:event) { :success! }
2018-12-13 13:39:08 +05:30
before do
2021-01-03 14:25:43 +05:30
allow(Deployments::UpdateEnvironmentWorker).to receive(:perform_async)
2022-08-13 15:12:31 +05:30
allow(Deployments::HooksWorker).to receive(:perform_async)
2018-12-13 13:39:08 +05:30
end
2021-04-29 21:17:54 +05:30
it_behaves_like 'avoid deadlock'
2021-09-30 23:02:18 +05:30
it_behaves_like 'calling proper BuildFinishedWorker'
2021-04-29 21:17:54 +05:30
2018-12-13 13:39:08 +05:30
it 'transits deployment status to success' do
2021-11-11 11:23:49 +05:30
with_cross_database_modification_prevented do
subject
end
2021-04-29 21:17:54 +05:30
2018-12-13 13:39:08 +05:30
expect(deployment).to be_success
end
end
context 'when transits to failed' do
2021-04-29 21:17:54 +05:30
let(:event) { :drop! }
it_behaves_like 'avoid deadlock'
2021-09-30 23:02:18 +05:30
it_behaves_like 'calling proper BuildFinishedWorker'
2018-12-13 13:39:08 +05:30
it 'transits deployment status to failed' do
2021-11-11 11:23:49 +05:30
with_cross_database_modification_prevented do
subject
end
2021-04-29 21:17:54 +05:30
2018-12-13 13:39:08 +05:30
expect(deployment).to be_failed
end
end
context 'when transits to skipped' do
2021-04-29 21:17:54 +05:30
let(:event) { :skip! }
it_behaves_like 'avoid deadlock'
2018-12-13 13:39:08 +05:30
2021-03-08 18:12:59 +05:30
it 'transits deployment status to skipped' do
2021-11-11 11:23:49 +05:30
with_cross_database_modification_prevented do
subject
end
2021-04-29 21:17:54 +05:30
2021-03-08 18:12:59 +05:30
expect(deployment).to be_skipped
2018-12-13 13:39:08 +05:30
end
end
context 'when transits to canceled' do
2021-04-29 21:17:54 +05:30
let(:event) { :cancel! }
it_behaves_like 'avoid deadlock'
2021-09-30 23:02:18 +05:30
it_behaves_like 'calling proper BuildFinishedWorker'
2018-12-13 13:39:08 +05:30
it 'transits deployment status to canceled' do
2021-11-11 11:23:49 +05:30
with_cross_database_modification_prevented do
subject
end
2021-04-29 21:17:54 +05:30
2018-12-13 13:39:08 +05:30
expect(deployment).to be_canceled
end
end
2022-07-16 23:28:13 +05:30
# Mimic playing a manual job that needs another job.
# `needs + when:manual` scenario, see: https://gitlab.com/gitlab-org/gitlab/-/issues/347502
context 'when transits from skipped to created to running' do
before do
build.skip!
end
context 'during skipped to created' do
let(:event) { :process! }
it 'transitions to created' do
subject
expect(deployment).to be_created
end
end
context 'during created to running' do
let(:event) { :run! }
before do
build.process!
build.enqueue!
end
it 'transitions to running and calls webhook' do
freeze_time do
2022-08-13 15:12:31 +05:30
expect(Deployments::HooksWorker)
.to receive(:perform_async).with(deployment_id: deployment.id, status: 'running', status_changed_at: Time.current)
2022-07-16 23:28:13 +05:30
subject
end
expect(deployment).to be_running
end
end
end
2018-12-13 13:39:08 +05:30
end
describe '#on_stop' do
subject { build.on_stop }
context 'when a job has a specification that it can be stopped from the other job' do
let(:build) { create(:ci_build, :start_review_app) }
it 'returns the other job name' do
is_expected.to eq('stop_review_app')
end
end
context 'when a job does not have environment information' do
let(:build) { create(:ci_build) }
it 'returns nil' do
is_expected.to be_nil
end
end
end
2022-08-27 11:52:29 +05:30
describe '#environment_tier_from_options' do
subject { build.environment_tier_from_options }
2021-04-17 20:07:23 +05:30
let(:build) { described_class.new(options: options) }
let(:options) { { environment: { deployment_tier: 'production' } } }
it { is_expected.to eq('production') }
context 'when options does not include deployment_tier' do
let(:options) { { environment: { name: 'production' } } }
it { is_expected.to be_nil }
end
end
2022-08-27 11:52:29 +05:30
describe '#environment_tier' do
subject { build.environment_tier }
let(:options) { { environment: { deployment_tier: 'production' } } }
let!(:environment) { create(:environment, name: 'production', tier: 'development', project: project) }
let(:build) { described_class.new(options: options, environment: 'production', project: project) }
it { is_expected.to eq('production') }
context 'when options does not include deployment_tier' do
let(:options) { { environment: { name: 'production' } } }
it 'uses tier from environment' do
is_expected.to eq('development')
end
context 'when persisted environment is absent' do
let(:environment) { nil }
it { is_expected.to be_nil }
end
end
end
2022-08-13 15:12:31 +05:30
describe 'environment' do
describe '#has_environment?' do
subject { build.has_environment? }
2017-08-17 22:00:37 +05:30
2022-08-13 15:12:31 +05:30
context 'when environment is defined' do
before do
build.update!(environment: 'review')
2017-08-17 22:00:37 +05:30
end
2022-08-13 15:12:31 +05:30
it { is_expected.to be_truthy }
2017-08-17 22:00:37 +05:30
end
2022-08-13 15:12:31 +05:30
context 'when environment is not defined' do
before do
build.update!(environment: nil)
end
2017-08-17 22:00:37 +05:30
it { is_expected.to be_falsey }
end
end
describe '#expanded_environment_name' do
subject { build.expanded_environment_name }
context 'when environment uses $CI_COMMIT_REF_NAME' do
let(:build) do
create(:ci_build,
ref: 'master',
environment: 'review/$CI_COMMIT_REF_NAME')
end
it { is_expected.to eq('review/master') }
end
context 'when environment uses yaml_variables containing symbol keys' do
let(:build) do
create(:ci_build,
yaml_variables: [{ key: :APP_HOST, value: 'host' }],
environment: 'review/$APP_HOST')
end
2020-04-08 14:13:33 +05:30
it 'returns an expanded environment name with a list of variables' do
is_expected.to eq('review/host')
end
context 'when build metadata has already persisted the expanded environment name' do
before do
2022-08-27 11:52:29 +05:30
build.metadata.expanded_environment_name = 'review/foo'
2020-04-08 14:13:33 +05:30
end
it 'returns a persisted expanded environment name without a list of variables' do
expect(build).not_to receive(:simple_variables)
2022-08-27 11:52:29 +05:30
is_expected.to eq('review/foo')
2020-04-08 14:13:33 +05:30
end
end
2017-08-17 22:00:37 +05:30
end
2018-11-08 19:23:39 +05:30
context 'when using persisted variables' do
let(:build) do
create(:ci_build, environment: 'review/x$CI_BUILD_ID')
end
it { is_expected.to eq('review/x') }
end
2022-06-21 17:19:12 +05:30
context 'when environment name uses a nested variable' do
let(:yaml_variables) do
[
{ key: 'ENVIRONMENT_NAME', value: '${CI_COMMIT_REF_NAME}' }
]
end
let(:build) do
create(:ci_build,
ref: 'master',
yaml_variables: yaml_variables,
environment: 'review/$ENVIRONMENT_NAME')
end
it { is_expected.to eq('review/master') }
end
2017-08-17 22:00:37 +05:30
end
2020-01-01 13:55:28 +05:30
describe '#expanded_kubernetes_namespace' do
let(:build) { create(:ci_build, environment: environment, options: options) }
subject { build.expanded_kubernetes_namespace }
context 'environment and namespace are not set' do
let(:environment) { nil }
let(:options) { nil }
it { is_expected.to be_nil }
end
context 'environment is specified' do
let(:environment) { 'production' }
context 'namespace is not set' do
let(:options) { nil }
it { is_expected.to be_nil }
end
context 'namespace is provided' do
let(:options) do
{
environment: {
name: environment,
kubernetes: {
namespace: namespace
}
}
}
end
context 'with a static value' do
let(:namespace) { 'production' }
it { is_expected.to eq namespace }
end
context 'with a dynamic value' do
2022-08-27 11:52:29 +05:30
let(:namespace) { 'deploy-$CI_COMMIT_REF_NAME' }
2020-01-01 13:55:28 +05:30
it { is_expected.to eq 'deploy-master' }
end
end
end
end
2017-08-17 22:00:37 +05:30
describe '#starts_environment?' do
subject { build.starts_environment? }
context 'when environment is defined' do
before do
2020-11-24 15:15:51 +05:30
build.update!(environment: 'review')
2017-08-17 22:00:37 +05:30
end
context 'no action is defined' do
it { is_expected.to be_truthy }
end
context 'and start action is defined' do
before do
2020-11-24 15:15:51 +05:30
build.update!(options: { environment: { action: 'start' } } )
2017-08-17 22:00:37 +05:30
end
it { is_expected.to be_truthy }
end
end
context 'when environment is not defined' do
before do
2020-11-24 15:15:51 +05:30
build.update!(environment: nil)
2017-08-17 22:00:37 +05:30
end
it { is_expected.to be_falsey }
end
end
describe '#stops_environment?' do
subject { build.stops_environment? }
context 'when environment is defined' do
before do
2020-11-24 15:15:51 +05:30
build.update!(environment: 'review')
2017-08-17 22:00:37 +05:30
end
context 'no action is defined' do
it { is_expected.to be_falsey }
end
context 'and stop action is defined' do
before do
2020-11-24 15:15:51 +05:30
build.update!(options: { environment: { action: 'stop' } } )
2017-08-17 22:00:37 +05:30
end
it { is_expected.to be_truthy }
end
end
context 'when environment is not defined' do
before do
2020-11-24 15:15:51 +05:30
build.update!(environment: nil)
2017-08-17 22:00:37 +05:30
end
it { is_expected.to be_falsey }
end
end
end
describe 'erasable build' do
shared_examples 'erasable' do
it 'removes artifact file' do
2019-09-04 21:01:54 +05:30
expect(build.artifacts_file.present?).to be_falsy
2017-08-17 22:00:37 +05:30
end
it 'removes artifact metadata file' do
2019-09-04 21:01:54 +05:30
expect(build.artifacts_metadata.present?).to be_falsy
2017-08-17 22:00:37 +05:30
end
2018-12-05 23:21:45 +05:30
it 'removes all job_artifacts' do
expect(build.job_artifacts.count).to eq(0)
2018-11-18 11:00:15 +05:30
end
2017-08-17 22:00:37 +05:30
it 'erases build trace in trace file' do
expect(build).not_to have_trace
end
it 'sets erased to true' do
expect(build.erased?).to be true
end
it 'sets erase date' do
expect(build.erased_at).not_to be_falsy
end
end
context 'build is not erasable' do
let!(:build) { create(:ci_build) }
describe '#erasable?' do
subject { build.erasable? }
2018-03-17 18:26:18 +05:30
2017-08-17 22:00:37 +05:30
it { is_expected.to eq false }
end
end
context 'build is erasable' do
2018-03-17 18:26:18 +05:30
context 'new artifacts' do
2018-11-18 11:00:15 +05:30
let!(:build) { create(:ci_build, :test_reports, :trace_artifact, :success, :artifacts) }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
describe '#erasable?' do
subject { build.erasable? }
2019-12-21 20:55:43 +05:30
2018-03-17 18:26:18 +05:30
it { is_expected.to be_truthy }
end
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
describe '#erased?' do
let!(:build) { create(:ci_build, :trace_artifact, :success, :artifacts) }
2020-03-13 15:44:24 +05:30
2018-03-17 18:26:18 +05:30
subject { build.erased? }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
context 'job has not been erased' do
it { is_expected.to be_falsey }
end
context 'job has been erased' do
before do
2022-10-11 01:57:18 +05:30
build.update!(erased_at: 1.minute.ago)
2018-03-17 18:26:18 +05:30
end
it { is_expected.to be_truthy }
end
2017-08-17 22:00:37 +05:30
end
2022-07-23 23:45:48 +05:30
end
end
2018-12-05 23:21:45 +05:30
end
2017-08-17 22:00:37 +05:30
describe '#failed_but_allowed?' do
subject { build.failed_but_allowed? }
context 'when build is not allowed to fail' do
before do
build.allow_failure = false
end
context 'and build.status is success' do
before do
build.status = 'success'
end
it { is_expected.to be_falsey }
end
context 'and build.status is failed' do
before do
build.status = 'failed'
end
it { is_expected.to be_falsey }
end
end
context 'when build is allowed to fail' do
before do
build.allow_failure = true
end
context 'and build.status is success' do
before do
build.status = 'success'
end
it { is_expected.to be_falsey }
end
context 'and build status is failed' do
before do
build.status = 'failed'
end
it { is_expected.to be_truthy }
end
context 'when build is a manual action' do
before do
build.status = 'manual'
end
it { is_expected.to be_falsey }
end
end
end
describe 'flags' do
describe '#cancelable?' do
subject { build }
context 'when build is cancelable' do
context 'when build is pending' do
it { is_expected.to be_cancelable }
end
context 'when build is running' do
before do
build.run!
end
it { is_expected.to be_cancelable }
end
2018-11-20 20:47:30 +05:30
context 'when build is created' do
let(:build) { create(:ci_build, :created) }
it { is_expected.to be_cancelable }
end
2020-03-13 15:44:24 +05:30
context 'when build is waiting for resource' do
let(:build) { create(:ci_build, :waiting_for_resource) }
it { is_expected.to be_cancelable }
end
2017-08-17 22:00:37 +05:30
end
context 'when build is not cancelable' do
context 'when build is successful' do
before do
build.success!
end
it { is_expected.not_to be_cancelable }
end
context 'when build is failed' do
before do
build.drop!
end
it { is_expected.not_to be_cancelable }
end
end
end
describe '#action?' do
before do
2020-11-24 15:15:51 +05:30
build.update!(when: value)
2017-08-17 22:00:37 +05:30
end
subject { build.action? }
context 'when is set to manual' do
let(:value) { 'manual' }
it { is_expected.to be_truthy }
end
2018-12-05 23:21:45 +05:30
context 'when is set to delayed' do
let(:value) { 'delayed' }
it { is_expected.to be_truthy }
end
2017-08-17 22:00:37 +05:30
context 'when set to something else' do
let(:value) { 'something else' }
it { is_expected.to be_falsey }
end
end
end
2021-09-30 23:02:18 +05:30
describe '#tag_list' do
let_it_be(:build) { create(:ci_build, tag_list: ['tag']) }
context 'when tags are preloaded' do
it 'does not trigger queries' do
build_with_tags = described_class.eager_load_tags.id_in([build]).to_a.first
expect { build_with_tags.tag_list }.not_to exceed_all_query_limit(0)
expect(build_with_tags.tag_list).to eq(['tag'])
end
end
context 'when tags are not preloaded' do
it { expect(described_class.find(build.id).tag_list).to eq(['tag']) }
end
end
2022-08-13 15:12:31 +05:30
describe '#save_tags' do
let(:build) { create(:ci_build, tag_list: ['tag']) }
it 'saves tags' do
build.save!
expect(build.tags.count).to eq(1)
expect(build.tags.first.name).to eq('tag')
end
it 'strips tags' do
build.tag_list = [' taga', 'tagb ', ' tagc ']
build.save!
expect(build.tags.map(&:name)).to match_array(%w[taga tagb tagc])
end
context 'with BulkInsertableTags.with_bulk_insert_tags' do
it 'does not save_tags' do
Ci::BulkInsertableTags.with_bulk_insert_tags do
build.save!
end
expect(build.tags).to be_empty
end
end
end
2017-08-17 22:00:37 +05:30
describe '#has_tags?' do
context 'when build has tags' do
subject { create(:ci_build, tag_list: ['tag']) }
it { is_expected.to have_tags }
end
context 'when build does not have tags' do
subject { create(:ci_build, tag_list: []) }
it { is_expected.not_to have_tags }
end
end
2017-09-10 17:25:29 +05:30
describe 'build auto retry feature' do
2022-03-02 08:16:31 +05:30
context 'with deployment job' do
let(:build) do
create(:ci_build, :deploy_to_production, :with_deployment,
user: user, pipeline: pipeline, project: project)
end
before do
project.add_developer(user)
allow(build).to receive(:auto_retry_allowed?) { true }
end
it 'creates a deployment when a build is dropped' do
expect { build.drop!(:script_failure) }.to change { Deployment.count }.by(1)
retried_deployment = Deployment.last
expect(build.deployment.environment).to eq(retried_deployment.environment)
expect(build.deployment.ref).to eq(retried_deployment.ref)
expect(build.deployment.sha).to eq(retried_deployment.sha)
expect(build.deployment.tag).to eq(retried_deployment.tag)
expect(build.deployment.user).to eq(retried_deployment.user)
expect(build.deployment).to be_failed
expect(retried_deployment).to be_created
end
end
2017-09-10 17:25:29 +05:30
describe '#retries_count' do
subject { create(:ci_build, name: 'test', pipeline: pipeline) }
context 'when build has been retried several times' do
before do
create(:ci_build, :retried, name: 'test', pipeline: pipeline)
create(:ci_build, :retried, name: 'test', pipeline: pipeline)
end
it 'reports a correct retry count value' do
expect(subject.retries_count).to eq 2
end
end
context 'when build has not been retried' do
it 'returns zero' do
expect(subject.retries_count).to eq 0
end
end
end
end
2020-07-28 23:09:34 +05:30
describe '.keep_artifacts!' do
let!(:build) { create(:ci_build, artifacts_expire_at: Time.current + 7.days) }
let!(:builds_for_update) do
Ci::Build.where(id: create_list(:ci_build, 3, artifacts_expire_at: Time.current + 7.days).map(&:id))
end
it 'resets expire_at' do
builds_for_update.keep_artifacts!
builds_for_update.each do |build|
expect(build.reload.artifacts_expire_at).to be_nil
end
end
it 'does not reset expire_at for other builds' do
builds_for_update.keep_artifacts!
expect(build.reload.artifacts_expire_at).to be_present
end
context 'when having artifacts files' do
let!(:artifact) { create(:ci_job_artifact, job: build, expire_in: '7 days') }
let!(:artifacts_for_update) do
builds_for_update.map do |build|
create(:ci_job_artifact, job: build, expire_in: '7 days')
end
end
it 'resets dependent objects' do
builds_for_update.keep_artifacts!
artifacts_for_update.each do |artifact|
expect(artifact.reload.expire_at).to be_nil
end
end
it 'does not reset dependent object for other builds' do
builds_for_update.keep_artifacts!
expect(artifact.reload.expire_at).to be_present
end
end
end
2017-08-17 22:00:37 +05:30
describe '#keep_artifacts!' do
2020-06-23 00:09:42 +05:30
let(:build) { create(:ci_build, artifacts_expire_at: Time.current + 7.days) }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
subject { build.keep_artifacts! }
2017-08-17 22:00:37 +05:30
it 'to reset expire_at' do
2018-03-17 18:26:18 +05:30
subject
2017-08-17 22:00:37 +05:30
expect(build.artifacts_expire_at).to be_nil
end
2018-03-17 18:26:18 +05:30
context 'when having artifacts files' do
let!(:artifact) { create(:ci_job_artifact, job: build, expire_in: '7 days') }
it 'to reset dependent objects' do
subject
expect(artifact.reload.expire_at).to be_nil
end
end
2017-08-17 22:00:37 +05:30
end
2022-03-02 08:16:31 +05:30
describe '#auto_retry_expected?' do
subject { create(:ci_build, :failed) }
context 'when build is failed and auto retry is configured' do
before do
allow(subject)
.to receive(:auto_retry_allowed?)
.and_return(true)
end
it 'expects auto-retry to happen' do
expect(subject.auto_retry_expected?).to be true
end
end
context 'when build failed by auto retry is not configured' do
it 'does not expect auto-retry to happen' do
expect(subject.auto_retry_expected?).to be false
end
end
end
2018-12-05 23:21:45 +05:30
describe '#artifacts_file_for_type' do
let(:build) { create(:ci_build, :artifacts) }
let(:file_type) { :archive }
subject { build.artifacts_file_for_type(file_type) }
it 'queries artifacts for type' do
2021-03-11 19:13:27 +05:30
expect(build).to receive_message_chain(:job_artifacts, :find_by).with(file_type: [Ci::JobArtifact.file_types[file_type]])
2018-12-05 23:21:45 +05:30
subject
end
end
2017-08-17 22:00:37 +05:30
describe '#merge_request' do
2020-04-22 19:07:51 +05:30
subject { pipeline.builds.take.merge_request }
2017-08-17 22:00:37 +05:30
2020-04-22 19:07:51 +05:30
context 'on a branch pipeline' do
let!(:pipeline) { create(:ci_pipeline, :with_job, project: project, ref: 'fix') }
2017-08-17 22:00:37 +05:30
2020-04-22 19:07:51 +05:30
context 'with no merge request' do
it { is_expected.to be_nil }
2017-08-17 22:00:37 +05:30
end
2020-04-22 19:07:51 +05:30
context 'with an open merge request from the same ref name' do
let!(:merge_request) { create(:merge_request, source_project: project, source_branch: 'fix') }
2017-08-17 22:00:37 +05:30
2020-04-22 19:07:51 +05:30
# If no diff exists, the pipeline commit was not part of the merge
# request and may have simply incidentally used the same ref name.
context 'without a merge request diff containing the pipeline commit' do
it { is_expected.to be_nil }
end
2017-08-17 22:00:37 +05:30
2020-04-22 19:07:51 +05:30
# If the merge request was truly opened from the branch that the
# pipeline ran on, that head sha will be present in a diff.
context 'with a merge request diff containing the pipeline commit' do
let!(:mr_diff) { create(:merge_request_diff, merge_request: merge_request) }
let!(:mr_diff_commit) { create(:merge_request_diff_commit, sha: build.sha, merge_request_diff: mr_diff) }
2017-08-17 22:00:37 +05:30
2020-04-22 19:07:51 +05:30
it { is_expected.to eq(merge_request) }
end
2017-08-17 22:00:37 +05:30
end
2020-04-22 19:07:51 +05:30
context 'with multiple open merge requests' do
let!(:merge_request) { create(:merge_request, source_project: project, source_branch: 'fix') }
let!(:mr_diff) { create(:merge_request_diff, merge_request: merge_request) }
let!(:mr_diff_commit) { create(:merge_request_diff_commit, sha: build.sha, merge_request_diff: mr_diff) }
let!(:new_merge_request) { create(:merge_request, source_project: project, source_branch: 'fix', target_branch: 'staging') }
let!(:new_mr_diff) { create(:merge_request_diff, merge_request: new_merge_request) }
let!(:new_mr_diff_commit) { create(:merge_request_diff_commit, sha: build.sha, merge_request_diff: new_mr_diff) }
it 'returns the first merge request' do
expect(subject).to eq(merge_request)
end
2017-08-17 22:00:37 +05:30
end
end
2020-04-22 19:07:51 +05:30
context 'on a detached merged request pipeline' do
let(:pipeline) { create(:ci_pipeline, :detached_merge_request_pipeline, :with_job) }
2017-08-17 22:00:37 +05:30
2020-04-22 19:07:51 +05:30
it { is_expected.to eq(pipeline.merge_request) }
end
2017-08-17 22:00:37 +05:30
2020-04-22 19:07:51 +05:30
context 'on a legacy detached merged request pipeline' do
let(:pipeline) { create(:ci_pipeline, :legacy_detached_merge_request_pipeline, :with_job) }
it { is_expected.to eq(pipeline.merge_request) }
end
context 'on a pipeline for merged results' do
let(:pipeline) { create(:ci_pipeline, :merged_result_pipeline, :with_job) }
it { is_expected.to eq(pipeline.merge_request) }
2017-08-17 22:00:37 +05:30
end
end
describe '#options' do
let(:options) do
{
2022-06-21 17:19:12 +05:30
image: "image:1.0",
2019-02-15 15:39:39 +05:30
services: ["postgres"],
script: ["ls -a"]
2017-08-17 22:00:37 +05:30
}
end
it 'contains options' do
2021-09-30 23:02:18 +05:30
expect(build.options).to eq(options.symbolize_keys)
2019-02-15 15:39:39 +05:30
end
2021-09-30 23:02:18 +05:30
it 'allows to access with symbolized keys' do
2022-06-21 17:19:12 +05:30
expect(build.options[:image]).to eq('image:1.0')
2019-02-15 15:39:39 +05:30
end
2021-09-30 23:02:18 +05:30
it 'rejects access with string keys' do
expect(build.options['image']).to be_nil
2019-02-15 15:39:39 +05:30
end
2021-10-27 15:23:28 +05:30
it 'persist data in build metadata' do
expect(build.metadata.read_attribute(:config_options)).to eq(options.symbolize_keys)
2019-02-15 15:39:39 +05:30
end
2021-10-27 15:23:28 +05:30
it 'does not persist data in build' do
expect(build.read_attribute(:options)).to be_nil
end
2019-12-26 22:10:19 +05:30
context 'when options include artifacts:expose_as' do
let(:build) { create(:ci_build, options: { artifacts: { expose_as: 'test' } }) }
it 'saves the presence of expose_as into build metadata' do
expect(build.metadata).to have_exposed_artifacts
end
end
2017-08-17 22:00:37 +05:30
end
2018-12-13 13:39:08 +05:30
describe '#other_manual_actions' do
2017-08-17 22:00:37 +05:30
let(:build) { create(:ci_build, :manual, pipeline: pipeline) }
let!(:other_build) { create(:ci_build, :manual, pipeline: pipeline, name: 'other action') }
2018-12-13 13:39:08 +05:30
subject { build.other_manual_actions }
2017-08-17 22:00:37 +05:30
before do
project.add_developer(user)
end
it 'returns other actions' do
is_expected.to contain_exactly(other_build)
end
context 'when build is retried' do
2022-06-21 17:19:12 +05:30
let!(:new_build) { Ci::RetryJobService.new(project, user).execute(build)[:job] }
2017-08-17 22:00:37 +05:30
it 'does not return any of them' do
is_expected.not_to include(build, new_build)
end
end
end
2018-12-13 13:39:08 +05:30
describe '#other_scheduled_actions' do
let(:build) { create(:ci_build, :scheduled, pipeline: pipeline) }
subject { build.other_scheduled_actions }
before do
project.add_developer(user)
end
context "when other build's status is success" do
let!(:other_build) { create(:ci_build, :schedulable, :success, pipeline: pipeline, name: 'other action') }
it 'returns other actions' do
is_expected.to contain_exactly(other_build)
end
end
context "when other build's status is failed" do
let!(:other_build) { create(:ci_build, :schedulable, :failed, pipeline: pipeline, name: 'other action') }
it 'returns other actions' do
is_expected.to contain_exactly(other_build)
end
end
context "when other build's status is running" do
let!(:other_build) { create(:ci_build, :schedulable, :running, pipeline: pipeline, name: 'other action') }
it 'does not return other actions' do
is_expected.to be_empty
end
end
context "when other build's status is scheduled" do
let!(:other_build) { create(:ci_build, :scheduled, pipeline: pipeline, name: 'other action') }
it 'does not return other actions' do
is_expected.to contain_exactly(other_build)
end
end
end
2017-08-17 22:00:37 +05:30
describe '#persisted_environment' do
let!(:environment) do
create(:environment, project: project, name: "foo-#{project.default_branch}")
end
subject { build.persisted_environment }
context 'when referenced literally' do
let(:build) do
create(:ci_build, pipeline: pipeline, environment: "foo-#{project.default_branch}")
end
it { is_expected.to eq(environment) }
end
context 'when referenced with a variable' do
let(:build) do
create(:ci_build, pipeline: pipeline, environment: "foo-$CI_COMMIT_REF_NAME")
end
it { is_expected.to eq(environment) }
end
2017-09-10 17:25:29 +05:30
context 'when there is no environment' do
it { is_expected.to be_nil }
end
2019-03-02 22:35:43 +05:30
context 'when build has a stop environment' do
2020-10-24 23:57:45 +05:30
let(:build) { create(:ci_build, :stop_review_app, pipeline: pipeline, environment: "foo-#{project.default_branch}") }
2019-03-02 22:35:43 +05:30
it 'expands environment name' do
2020-10-24 23:57:45 +05:30
expect(build).to receive(:expanded_environment_name).and_call_original
2019-03-02 22:35:43 +05:30
2020-10-24 23:57:45 +05:30
is_expected.to eq(environment)
2019-03-02 22:35:43 +05:30
end
end
2017-08-17 22:00:37 +05:30
end
describe '#play' do
let(:build) { create(:ci_build, :manual, pipeline: pipeline) }
before do
project.add_developer(user)
end
it 'enqueues the build' do
expect(build.play(user)).to be_pending
end
end
2018-11-08 19:23:39 +05:30
describe '#playable?' do
context 'when build is a manual action' do
context 'when build has been skipped' do
subject { build_stubbed(:ci_build, :manual, status: :skipped) }
it { is_expected.not_to be_playable }
end
context 'when build has been canceled' do
subject { build_stubbed(:ci_build, :manual, status: :canceled) }
it { is_expected.to be_playable }
end
context 'when build is successful' do
subject { build_stubbed(:ci_build, :manual, status: :success) }
it { is_expected.to be_playable }
end
context 'when build has failed' do
subject { build_stubbed(:ci_build, :manual, status: :failed) }
it { is_expected.to be_playable }
end
context 'when build is a manual untriggered action' do
subject { build_stubbed(:ci_build, :manual, status: :manual) }
it { is_expected.to be_playable }
end
2018-12-13 13:39:08 +05:30
context 'when build is a manual and degenerated' do
subject { build_stubbed(:ci_build, :manual, :degenerated, status: :manual) }
it { is_expected.not_to be_playable }
end
2018-11-08 19:23:39 +05:30
end
2018-12-05 23:21:45 +05:30
context 'when build is scheduled' do
subject { build_stubbed(:ci_build, :scheduled) }
it { is_expected.to be_playable }
end
2018-11-08 19:23:39 +05:30
context 'when build is not a manual action' do
subject { build_stubbed(:ci_build, :success) }
it { is_expected.not_to be_playable }
end
2022-03-02 08:16:31 +05:30
context 'when build is waiting for deployment approval' do
subject { build_stubbed(:ci_build, :manual, environment: 'production') }
before do
create(:deployment, :blocked, deployable: subject)
end
it { is_expected.not_to be_playable }
end
2018-11-08 19:23:39 +05:30
end
2017-08-17 22:00:37 +05:30
describe 'project settings' do
describe '#allow_git_fetch' do
it 'return project allow_git_fetch configuration' do
expect(build.allow_git_fetch).to eq(project.build_allow_git_fetch)
end
end
end
2016-09-29 09:46:39 +05:30
2017-08-17 22:00:37 +05:30
describe '#project' do
subject { build.project }
it { is_expected.to eq(pipeline.project) }
end
describe '#project_id' do
subject { build.project_id }
it { is_expected.to eq(pipeline.project_id) }
end
describe '#project_name' do
subject { build.project_name }
it { is_expected.to eq(project.name) }
end
describe '#ref_slug' do
{
2022-10-11 01:57:18 +05:30
'master' => 'master',
'1-foo' => '1-foo',
'fix/1-foo' => 'fix-1-foo',
'fix-1-foo' => 'fix-1-foo',
'a' * 63 => 'a' * 63,
'a' * 64 => 'a' * 63,
'FOO' => 'foo',
'-' + 'a' * 61 + '-' => 'a' * 61,
'-' + 'a' * 62 + '-' => 'a' * 62,
'-' + 'a' * 63 + '-' => 'a' * 62,
'a' * 62 + ' ' => 'a' * 62
2017-08-17 22:00:37 +05:30
}.each do |ref, slug|
it "transforms #{ref} to #{slug}" do
build.ref = ref
expect(build.ref_slug).to eq(slug)
end
2016-09-29 09:46:39 +05:30
end
2017-08-17 22:00:37 +05:30
end
describe '#repo_url' do
subject { build.repo_url }
2019-02-15 15:39:39 +05:30
context 'when token is set' do
before do
build.ensure_token
end
it { is_expected.to be_a(String) }
it { is_expected.to end_with(".git") }
it { is_expected.to start_with(project.web_url[0..6]) }
it { is_expected.to include(build.token) }
it { is_expected.to include('gitlab-ci-token') }
2022-01-26 12:08:38 +05:30
it { is_expected.to include(project.web_url[7..]) }
2019-02-15 15:39:39 +05:30
end
context 'when token is empty' do
before do
2022-08-13 15:12:31 +05:30
build.update_columns(token_encrypted: nil)
2019-02-15 15:39:39 +05:30
end
2022-08-27 11:52:29 +05:30
it { is_expected.to be_nil }
2019-02-15 15:39:39 +05:30
end
2017-08-17 22:00:37 +05:30
end
describe '#stuck?' do
subject { build.stuck? }
context "when commit_status.status is pending" do
before do
build.status = 'pending'
end
it { is_expected.to be_truthy }
2016-09-29 09:46:39 +05:30
2017-08-17 22:00:37 +05:30
context "and there are specific runner" do
2018-11-08 19:23:39 +05:30
let!(:runner) { create(:ci_runner, :project, projects: [build.project], contacted_at: 1.second.ago) }
2016-09-29 09:46:39 +05:30
2017-08-17 22:00:37 +05:30
it { is_expected.to be_falsey }
2016-09-29 09:46:39 +05:30
end
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
%w[success failed canceled running].each do |state|
context "when commit_status.status is #{state}" do
2016-09-29 09:46:39 +05:30
before do
2017-08-17 22:00:37 +05:30
build.status = state
2016-09-29 09:46:39 +05:30
end
2017-08-17 22:00:37 +05:30
it { is_expected.to be_falsey }
end
end
end
2021-01-03 14:25:43 +05:30
describe '#has_expired_locked_archive_artifacts?' do
subject { build.has_expired_locked_archive_artifacts? }
context 'when build does not have artifacts' do
it { is_expected.to eq(nil) }
end
context 'when build has artifacts' do
before do
create(:ci_job_artifact, :archive, job: build)
end
context 'when artifacts are unlocked' do
before do
build.pipeline.unlocked!
end
it { is_expected.to eq(false) }
end
context 'when artifacts are locked' do
before do
build.pipeline.artifacts_locked!
end
context 'when artifacts do not expire' do
it { is_expected.to eq(false) }
end
context 'when artifacts expire in the future' do
before do
build.update!(artifacts_expire_at: 1.day.from_now)
end
it { is_expected.to eq(false) }
end
context 'when artifacts expired in the past' do
before do
build.update!(artifacts_expire_at: 1.day.ago)
end
it { is_expected.to eq(true) }
end
end
end
end
2020-03-13 15:44:24 +05:30
describe '#has_expiring_archive_artifacts?' do
2017-08-17 22:00:37 +05:30
context 'when artifacts have expiration date set' do
2017-09-10 17:25:29 +05:30
before do
2020-11-24 15:15:51 +05:30
build.update!(artifacts_expire_at: 1.day.from_now)
2017-09-10 17:25:29 +05:30
end
2017-08-17 22:00:37 +05:30
2020-03-13 15:44:24 +05:30
context 'and job artifacts archive record exists' do
let!(:archive) { create(:ci_job_artifact, :archive, job: build) }
it 'has expiring artifacts' do
expect(build).to have_expiring_archive_artifacts
end
end
context 'and job artifacts archive record does not exist' do
it 'does not have expiring artifacts' do
expect(build).not_to have_expiring_archive_artifacts
end
2017-08-17 22:00:37 +05:30
end
end
context 'when artifacts do not have expiration date set' do
2017-09-10 17:25:29 +05:30
before do
2020-11-24 15:15:51 +05:30
build.update!(artifacts_expire_at: nil)
2017-09-10 17:25:29 +05:30
end
2017-08-17 22:00:37 +05:30
it 'does not have expiring artifacts' do
2020-03-13 15:44:24 +05:30
expect(build).not_to have_expiring_archive_artifacts
2017-08-17 22:00:37 +05:30
end
end
end
2019-02-15 15:39:39 +05:30
describe '#variables' do
let(:container_registry_enabled) { false }
before do
stub_container_registry_config(enabled: container_registry_enabled, host_port: 'registry.example.com')
2021-02-22 17:27:13 +05:30
stub_config(dependency_proxy: { enabled: true })
2019-02-15 15:39:39 +05:30
end
subject { build.variables }
context 'returns variables' do
let(:predefined_variables) do
[
2019-07-07 11:18:12 +05:30
{ key: 'CI_PIPELINE_ID', value: pipeline.id.to_s, public: true, masked: false },
2020-06-23 00:09:42 +05:30
{ key: 'CI_PIPELINE_URL', value: project.web_url + "/-/pipelines/#{pipeline.id}", public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_JOB_ID', value: build.id.to_s, public: true, masked: false },
{ key: 'CI_JOB_URL', value: project.web_url + "/-/jobs/#{build.id}", public: true, masked: false },
{ key: 'CI_JOB_TOKEN', value: 'my-token', public: false, masked: true },
2021-04-17 20:07:23 +05:30
{ key: 'CI_JOB_STARTED_AT', value: build.started_at&.iso8601, public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_BUILD_ID', value: build.id.to_s, public: true, masked: false },
{ key: 'CI_BUILD_TOKEN', value: 'my-token', public: false, masked: true },
{ key: 'CI_REGISTRY_USER', value: 'gitlab-ci-token', public: true, masked: false },
{ key: 'CI_REGISTRY_PASSWORD', value: 'my-token', public: false, masked: true },
{ key: 'CI_REPOSITORY_URL', value: build.repo_url, public: false, masked: false },
2021-02-22 17:27:13 +05:30
{ key: 'CI_DEPENDENCY_PROXY_USER', value: 'gitlab-ci-token', public: true, masked: false },
{ key: 'CI_DEPENDENCY_PROXY_PASSWORD', value: 'my-token', public: false, masked: true },
2020-04-22 19:07:51 +05:30
{ key: 'CI_JOB_JWT', value: 'ci.job.jwt', public: false, masked: true },
2022-03-02 08:16:31 +05:30
{ key: 'CI_JOB_JWT_V1', value: 'ci.job.jwt', public: false, masked: true },
{ key: 'CI_JOB_JWT_V2', value: 'ci.job.jwtv2', public: false, masked: true },
2020-01-01 13:55:28 +05:30
{ key: 'CI_JOB_NAME', value: 'test', public: true, masked: false },
2022-11-25 23:54:43 +05:30
{ key: 'CI_JOB_NAME_SLUG', value: 'test', public: true, masked: false },
2020-01-01 13:55:28 +05:30
{ key: 'CI_JOB_STAGE', value: 'test', public: true, masked: false },
{ key: 'CI_NODE_TOTAL', value: '1', public: true, masked: false },
{ key: 'CI_BUILD_NAME', value: 'test', public: true, masked: false },
{ key: 'CI_BUILD_STAGE', value: 'test', public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI', value: 'true', public: true, masked: false },
{ key: 'GITLAB_CI', value: 'true', public: true, masked: false },
2020-03-13 15:44:24 +05:30
{ key: 'CI_SERVER_URL', value: Gitlab.config.gitlab.url, public: true, masked: false },
2019-09-30 21:07:59 +05:30
{ key: 'CI_SERVER_HOST', value: Gitlab.config.gitlab.host, public: true, masked: false },
2020-03-13 15:44:24 +05:30
{ key: 'CI_SERVER_PORT', value: Gitlab.config.gitlab.port.to_s, public: true, masked: false },
{ key: 'CI_SERVER_PROTOCOL', value: Gitlab.config.gitlab.protocol, public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_SERVER_NAME', value: 'GitLab', public: true, masked: false },
{ key: 'CI_SERVER_VERSION', value: Gitlab::VERSION, public: true, masked: false },
{ key: 'CI_SERVER_VERSION_MAJOR', value: Gitlab.version_info.major.to_s, public: true, masked: false },
{ key: 'CI_SERVER_VERSION_MINOR', value: Gitlab.version_info.minor.to_s, public: true, masked: false },
{ key: 'CI_SERVER_VERSION_PATCH', value: Gitlab.version_info.patch.to_s, public: true, masked: false },
{ key: 'CI_SERVER_REVISION', value: Gitlab.revision, public: true, masked: false },
2020-01-01 13:55:28 +05:30
{ key: 'GITLAB_FEATURES', value: project.licensed_features.join(','), public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_PROJECT_ID', value: project.id.to_s, public: true, masked: false },
{ key: 'CI_PROJECT_NAME', value: project.path, public: true, masked: false },
2019-12-21 20:55:43 +05:30
{ key: 'CI_PROJECT_TITLE', value: project.title, public: true, masked: false },
2022-07-23 23:45:48 +05:30
{ key: 'CI_PROJECT_DESCRIPTION', value: project.description, public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_PROJECT_PATH', value: project.full_path, public: true, masked: false },
{ key: 'CI_PROJECT_PATH_SLUG', value: project.full_path_slug, public: true, masked: false },
{ key: 'CI_PROJECT_NAMESPACE', value: project.namespace.full_path, public: true, masked: false },
2020-07-28 23:09:34 +05:30
{ key: 'CI_PROJECT_ROOT_NAMESPACE', value: project.namespace.root_ancestor.path, public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_PROJECT_URL', value: project.web_url, public: true, masked: false },
{ key: 'CI_PROJECT_VISIBILITY', value: 'private', public: true, masked: false },
2019-12-04 20:38:33 +05:30
{ key: 'CI_PROJECT_REPOSITORY_LANGUAGES', value: project.repository_languages.map(&:name).join(',').downcase, public: true, masked: false },
2021-10-27 15:23:28 +05:30
{ key: 'CI_PROJECT_CLASSIFICATION_LABEL', value: project.external_authorization_classification_label, public: true, masked: false },
2020-01-01 13:55:28 +05:30
{ key: 'CI_DEFAULT_BRANCH', value: project.default_branch, public: true, masked: false },
2021-04-17 20:07:23 +05:30
{ key: 'CI_CONFIG_PATH', value: project.ci_config_path_or_default, public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_PAGES_DOMAIN', value: Gitlab.config.pages.host, public: true, masked: false },
{ key: 'CI_PAGES_URL', value: project.pages_url, public: true, masked: false },
2021-04-17 20:07:23 +05:30
{ key: 'CI_DEPENDENCY_PROXY_SERVER', value: Gitlab.host_with_port, public: true, masked: false },
2021-02-22 17:27:13 +05:30
{ key: 'CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX',
2021-04-17 20:07:23 +05:30
value: "#{Gitlab.host_with_port}/#{project.namespace.root_ancestor.path.downcase}#{DependencyProxy::URL_SUFFIX}",
2021-02-22 17:27:13 +05:30
public: true,
masked: false },
2021-11-11 11:23:49 +05:30
{ key: 'CI_DEPENDENCY_PROXY_DIRECT_GROUP_IMAGE_PREFIX',
value: "#{Gitlab.host_with_port}/#{project.namespace.full_path.downcase}#{DependencyProxy::URL_SUFFIX}",
public: true,
masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_API_V4_URL', value: 'http://localhost/api/v4', public: true, masked: false },
2022-08-27 11:52:29 +05:30
{ key: 'CI_TEMPLATE_REGISTRY_HOST', value: template_registry_host, public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_PIPELINE_IID', value: pipeline.iid.to_s, public: true, masked: false },
{ key: 'CI_PIPELINE_SOURCE', value: pipeline.source, public: true, masked: false },
2021-04-17 20:07:23 +05:30
{ key: 'CI_PIPELINE_CREATED_AT', value: pipeline.created_at.iso8601, public: true, masked: false },
2020-01-01 13:55:28 +05:30
{ key: 'CI_COMMIT_SHA', value: build.sha, public: true, masked: false },
{ key: 'CI_COMMIT_SHORT_SHA', value: build.short_sha, public: true, masked: false },
{ key: 'CI_COMMIT_BEFORE_SHA', value: build.before_sha, public: true, masked: false },
{ key: 'CI_COMMIT_REF_NAME', value: build.ref, public: true, masked: false },
{ key: 'CI_COMMIT_REF_SLUG', value: build.ref_slug, public: true, masked: false },
{ key: 'CI_COMMIT_BRANCH', value: build.ref, public: true, masked: false },
2019-07-07 11:18:12 +05:30
{ key: 'CI_COMMIT_MESSAGE', value: pipeline.git_commit_message, public: true, masked: false },
{ key: 'CI_COMMIT_TITLE', value: pipeline.git_commit_title, public: true, masked: false },
2019-07-31 22:56:46 +05:30
{ key: 'CI_COMMIT_DESCRIPTION', value: pipeline.git_commit_description, public: true, masked: false },
2020-01-01 13:55:28 +05:30
{ key: 'CI_COMMIT_REF_PROTECTED', value: (!!pipeline.protected_ref?).to_s, public: true, masked: false },
2020-11-24 15:15:51 +05:30
{ key: 'CI_COMMIT_TIMESTAMP', value: pipeline.git_commit_timestamp, public: true, masked: false },
2021-04-29 21:17:54 +05:30
{ key: 'CI_COMMIT_AUTHOR', value: pipeline.git_author_full_text, public: true, masked: false },
2020-01-01 13:55:28 +05:30
{ key: 'CI_BUILD_REF', value: build.sha, public: true, masked: false },
{ key: 'CI_BUILD_BEFORE_SHA', value: build.before_sha, public: true, masked: false },
{ key: 'CI_BUILD_REF_NAME', value: build.ref, public: true, masked: false },
{ key: 'CI_BUILD_REF_SLUG', value: build.ref_slug, public: true, masked: false }
2019-02-15 15:39:39 +05:30
]
end
2017-08-17 22:00:37 +05:30
before do
2021-01-29 00:20:46 +05:30
allow(Gitlab::Ci::Jwt).to receive(:for_build).and_return('ci.job.jwt')
2022-03-02 08:16:31 +05:30
allow(Gitlab::Ci::JwtV2).to receive(:for_build).and_return('ci.job.jwtv2')
2019-02-15 15:39:39 +05:30
build.set_token('my-token')
build.yaml_variables = []
2016-09-29 09:46:39 +05:30
end
2021-04-17 20:07:23 +05:30
it { is_expected.to be_instance_of(Gitlab::Ci::Variables::Collection) }
it { expect(subject.to_runner_variables).to eq(predefined_variables) }
2018-03-17 18:26:18 +05:30
2021-09-04 01:27:46 +05:30
it 'excludes variables that require an environment or user' do
environment_based_variables_collection = subject.filter do |variable|
%w[
YAML_VARIABLE CI_ENVIRONMENT_NAME CI_ENVIRONMENT_SLUG
CI_ENVIRONMENT_ACTION CI_ENVIRONMENT_URL
].include?(variable[:key])
end
expect(environment_based_variables_collection).to be_empty
end
2020-04-22 19:07:51 +05:30
context 'when ci_job_jwt feature flag is disabled' do
before do
stub_feature_flags(ci_job_jwt: false)
end
it 'CI_JOB_JWT is not included' do
expect(subject.pluck(:key)).not_to include('CI_JOB_JWT')
end
end
2020-05-05 14:28:15 +05:30
context 'when CI_JOB_JWT generation fails' do
2021-01-29 00:20:46 +05:30
[
OpenSSL::PKey::RSAError,
Gitlab::Ci::Jwt::NoSigningKeyError
].each do |reason_to_fail|
it 'CI_JOB_JWT is not included' do
expect(Gitlab::Ci::Jwt).to receive(:for_build).and_raise(reason_to_fail)
expect(Gitlab::ErrorTracking).to receive(:track_exception)
expect { subject }.not_to raise_error
expect(subject.pluck(:key)).not_to include('CI_JOB_JWT')
end
2020-05-05 14:28:15 +05:30
end
end
2022-11-25 23:54:43 +05:30
context 'when the opt_in_jwt project setting is true' do
it 'does not include the JWT variables' do
project.ci_cd_settings.update!(opt_in_jwt: true)
expect(subject.pluck(:key)).not_to include('CI_JOB_JWT', 'CI_JOB_JWT_V1', 'CI_JOB_JWT_V2')
end
end
2019-02-15 15:39:39 +05:30
describe 'variables ordering' do
context 'when variables hierarchy is stubbed' do
2019-07-07 11:18:12 +05:30
let(:build_pre_var) { { key: 'build', value: 'value', public: true, masked: false } }
let(:project_pre_var) { { key: 'project', value: 'value', public: true, masked: false } }
let(:pipeline_pre_var) { { key: 'pipeline', value: 'value', public: true, masked: false } }
let(:build_yaml_var) { { key: 'yaml', value: 'value', public: true, masked: false } }
2021-02-22 17:27:13 +05:30
let(:dependency_proxy_var) { { key: 'dependency_proxy', value: 'value', public: true, masked: false } }
2020-04-22 19:07:51 +05:30
let(:job_jwt_var) { { key: 'CI_JOB_JWT', value: 'ci.job.jwt', public: false, masked: true } }
2022-03-02 08:16:31 +05:30
let(:job_jwt_var_v1) { { key: 'CI_JOB_JWT_V1', value: 'ci.job.jwt', public: false, masked: true } }
let(:job_jwt_var_v2) { { key: 'CI_JOB_JWT_V2', value: 'ci.job.jwtv2', public: false, masked: true } }
2020-05-24 23:13:21 +05:30
let(:job_dependency_var) { { key: 'job_dependency', value: 'value', public: true, masked: false } }
2019-02-15 15:39:39 +05:30
before do
2021-12-11 22:18:48 +05:30
allow_next_instance_of(Gitlab::Ci::Variables::Builder) do |builder|
allow(builder).to receive(:predefined_variables) { [build_pre_var] }
end
2019-02-15 15:39:39 +05:30
allow(build).to receive(:yaml_variables) { [build_yaml_var] }
allow(build).to receive(:persisted_variables) { [] }
2020-04-22 19:07:51 +05:30
allow(build).to receive(:job_jwt_variables) { [job_jwt_var] }
2020-05-24 23:13:21 +05:30
allow(build).to receive(:dependency_variables) { [job_dependency_var] }
2021-02-22 17:27:13 +05:30
allow(build).to receive(:dependency_proxy_variables) { [dependency_proxy_var] }
2016-09-29 09:46:39 +05:30
2022-03-02 08:16:31 +05:30
allow(build.pipeline.project)
2019-02-15 15:39:39 +05:30
.to receive(:predefined_variables) { [project_pre_var] }
2017-08-17 22:00:37 +05:30
2019-02-15 15:39:39 +05:30
project.variables.create!(key: 'secret', value: 'value')
2017-08-17 22:00:37 +05:30
2020-06-23 00:09:42 +05:30
allow(build.pipeline)
.to receive(:predefined_variables).and_return([pipeline_pre_var])
2017-08-17 22:00:37 +05:30
end
2019-02-15 15:39:39 +05:30
it 'returns variables in order depending on resource hierarchy' do
2021-04-17 20:07:23 +05:30
expect(subject.to_runner_variables).to eq(
2021-02-22 17:27:13 +05:30
[dependency_proxy_var,
job_jwt_var,
2020-04-22 19:07:51 +05:30
build_pre_var,
2019-02-15 15:39:39 +05:30
project_pre_var,
pipeline_pre_var,
build_yaml_var,
2020-05-24 23:13:21 +05:30
job_dependency_var,
2019-07-07 11:18:12 +05:30
{ key: 'secret', value: 'value', public: false, masked: false }])
2019-02-15 15:39:39 +05:30
end
2017-08-17 22:00:37 +05:30
end
2019-02-15 15:39:39 +05:30
context 'when build has environment and user-provided variables' do
let(:expected_variables) do
predefined_variables.map { |variable| variable.fetch(:key) } +
%w[YAML_VARIABLE CI_ENVIRONMENT_NAME CI_ENVIRONMENT_SLUG
2022-08-27 11:52:29 +05:30
CI_ENVIRONMENT_ACTION CI_ENVIRONMENT_TIER CI_ENVIRONMENT_URL]
2017-08-17 22:00:37 +05:30
end
2019-02-15 15:39:39 +05:30
before do
create(:environment, project: build.project,
name: 'staging')
2017-08-17 22:00:37 +05:30
2019-02-15 15:39:39 +05:30
build.yaml_variables = [{ key: 'YAML_VARIABLE',
value: 'var',
public: true }]
build.environment = 'staging'
end
2017-08-17 22:00:37 +05:30
2019-02-15 15:39:39 +05:30
it 'matches explicit variables ordering' do
2021-04-17 20:07:23 +05:30
received_variables = subject.map { |variable| variable[:key] }
2017-08-17 22:00:37 +05:30
2019-02-15 15:39:39 +05:30
expect(received_variables).to eq expected_variables
end
2021-09-04 01:27:46 +05:30
describe 'CI_ENVIRONMENT_ACTION' do
let(:enviroment_action_variable) { subject.find { |variable| variable[:key] == 'CI_ENVIRONMENT_ACTION' } }
shared_examples 'defaults value' do
it 'value matches start' do
expect(enviroment_action_variable[:value]).to eq('start')
end
end
it_behaves_like 'defaults value'
context 'when options is set' do
before do
build.update!(options: options)
end
context 'when options is empty' do
let(:options) { {} }
it_behaves_like 'defaults value'
end
context 'when options is nil' do
let(:options) { nil }
it_behaves_like 'defaults value'
end
context 'when options environment is specified' do
let(:options) { { environment: {} } }
it_behaves_like 'defaults value'
end
context 'when options environment action specified' do
let(:options) { { environment: { action: 'stop' } } }
it 'matches the specified action' do
expect(enviroment_action_variable[:value]).to eq('stop')
end
end
end
end
2019-02-15 15:39:39 +05:30
end
2017-08-17 22:00:37 +05:30
end
end
context 'when build has user' do
let(:user_variables) do
2018-03-17 18:26:18 +05:30
[
2019-07-07 11:18:12 +05:30
{ key: 'GITLAB_USER_ID', value: user.id.to_s, public: true, masked: false },
{ key: 'GITLAB_USER_EMAIL', value: user.email, public: true, masked: false },
{ key: 'GITLAB_USER_LOGIN', value: user.username, public: true, masked: false },
{ key: 'GITLAB_USER_NAME', value: user.name, public: true, masked: false }
2018-03-17 18:26:18 +05:30
]
2017-08-17 22:00:37 +05:30
end
before do
2020-11-24 15:15:51 +05:30
build.update!(user: user)
2017-08-17 22:00:37 +05:30
end
it { user_variables.each { |v| is_expected.to include(v) } }
end
2019-07-07 11:18:12 +05:30
context 'when build belongs to a pipeline for merge request' do
let(:merge_request) { create(:merge_request, :with_detached_merge_request_pipeline, source_branch: 'improve/awesome') }
let(:pipeline) { merge_request.all_pipelines.first }
let(:build) { create(:ci_build, ref: pipeline.ref, pipeline: pipeline) }
it 'returns values based on source ref' do
is_expected.to include(
{ key: 'CI_COMMIT_REF_NAME', value: 'improve/awesome', public: true, masked: false },
{ key: 'CI_COMMIT_REF_SLUG', value: 'improve-awesome', public: true, masked: false }
)
end
end
2017-08-17 22:00:37 +05:30
context 'when build has an environment' do
let(:environment_variables) do
[
2019-07-07 11:18:12 +05:30
{ key: 'CI_ENVIRONMENT_NAME', value: 'production', public: true, masked: false },
2021-09-04 01:27:46 +05:30
{ key: 'CI_ENVIRONMENT_SLUG', value: 'prod-slug', public: true, masked: false },
{ key: 'CI_ENVIRONMENT_TIER', value: 'production', public: true, masked: false }
2017-08-17 22:00:37 +05:30
]
end
2017-09-10 17:25:29 +05:30
let!(:environment) do
create(:environment,
2018-03-17 18:26:18 +05:30
project: build.project,
name: 'production',
slug: 'prod-slug',
2021-09-04 01:27:46 +05:30
tier: 'production',
2018-03-17 18:26:18 +05:30
external_url: '')
2017-09-10 17:25:29 +05:30
end
before do
2020-11-24 15:15:51 +05:30
build.update!(environment: 'production')
2017-09-10 17:25:29 +05:30
end
shared_examples 'containing environment variables' do
2021-04-17 20:07:23 +05:30
it { is_expected.to include(*environment_variables) }
2017-09-10 17:25:29 +05:30
end
context 'when no URL was set' do
it_behaves_like 'containing environment variables'
it 'does not have CI_ENVIRONMENT_URL' do
2021-04-17 20:07:23 +05:30
keys = subject.pluck(:key)
2017-09-10 17:25:29 +05:30
expect(keys).not_to include('CI_ENVIRONMENT_URL')
end
end
context 'when an URL was set' do
let(:url) { 'http://host/test' }
before do
environment_variables <<
2019-07-07 11:18:12 +05:30
{ key: 'CI_ENVIRONMENT_URL', value: url, public: true, masked: false }
2017-09-10 17:25:29 +05:30
end
context 'when the URL was set from the job' do
before do
2020-11-24 15:15:51 +05:30
build.update!(options: { environment: { url: url } })
2017-09-10 17:25:29 +05:30
end
it_behaves_like 'containing environment variables'
context 'when variables are used in the URL, it does not expand' do
let(:url) { 'http://$CI_PROJECT_NAME-$CI_ENVIRONMENT_SLUG' }
it_behaves_like 'containing environment variables'
it 'puts $CI_ENVIRONMENT_URL in the last so all other variables are available to be used when runners are trying to expand it' do
2021-04-17 20:07:23 +05:30
expect(subject.to_runner_variables.last).to eq(environment_variables.last)
2017-09-10 17:25:29 +05:30
end
end
end
context 'when the URL was not set from the job, but environment' do
before do
2020-11-24 15:15:51 +05:30
environment.update!(external_url: url)
2017-09-10 17:25:29 +05:30
end
it_behaves_like 'containing environment variables'
end
end
2019-10-12 21:52:04 +05:30
2022-08-27 11:52:29 +05:30
context 'when environment_tier is updated in options' do
before do
build.update!(options: { environment: { name: 'production', deployment_tier: 'development' } })
end
it 'uses tier from options' do
is_expected.to include({ key: 'CI_ENVIRONMENT_TIER', value: 'development', public: true, masked: false })
end
end
2019-10-12 21:52:04 +05:30
context 'when project has an environment specific variable' do
let(:environment_specific_variable) do
{ key: 'MY_STAGING_ONLY_VARIABLE', value: 'environment_specific_variable', public: false, masked: false }
end
before do
create(:ci_variable, environment_specific_variable.slice(:key, :value)
.merge(project: project, environment_scope: 'stag*'))
end
it_behaves_like 'containing environment variables'
context 'when environment scope does not match build environment' do
it { is_expected.not_to include(environment_specific_variable) }
end
context 'when environment scope matches build environment' do
before do
create(:environment, name: 'staging', project: project)
build.update!(environment: 'staging')
end
it { is_expected.to include(environment_specific_variable) }
end
end
2017-08-17 22:00:37 +05:30
end
context 'when build started manually' do
before do
2020-11-24 15:15:51 +05:30
build.update!(when: :manual)
2017-08-17 22:00:37 +05:30
end
let(:manual_variable) do
2019-07-07 11:18:12 +05:30
{ key: 'CI_JOB_MANUAL', value: 'true', public: true, masked: false }
2017-08-17 22:00:37 +05:30
end
it { is_expected.to include(manual_variable) }
end
2019-10-12 21:52:04 +05:30
context 'when job variable is defined' do
let(:job_variable) { { key: 'first', value: 'first', public: false, masked: false } }
before do
create(:ci_job_variable, job_variable.slice(:key, :value).merge(job: build))
end
it { is_expected.to include(job_variable) }
end
2020-01-01 13:55:28 +05:30
context 'when build is for branch' do
let(:branch_variable) do
{ key: 'CI_COMMIT_BRANCH', value: 'master', public: true, masked: false }
end
before do
2020-11-24 15:15:51 +05:30
build.update!(tag: false)
pipeline.update!(tag: false)
2020-01-01 13:55:28 +05:30
end
it { is_expected.to include(branch_variable) }
end
2017-08-17 22:00:37 +05:30
context 'when build is for tag' do
2022-11-25 23:54:43 +05:30
let(:tag_name) { project.repository.tags.first.name }
let(:tag_message) { project.repository.tags.first.message }
let!(:pipeline) do
create(:ci_pipeline, project: project,
sha: project.commit.id,
ref: tag_name,
status: 'success')
end
let!(:build) { create(:ci_build, pipeline: pipeline, ref: tag_name) }
2017-08-17 22:00:37 +05:30
let(:tag_variable) do
2022-11-25 23:54:43 +05:30
{ key: 'CI_COMMIT_TAG', value: tag_name, public: true, masked: false }
end
let(:tag_message_variable) do
{ key: 'CI_COMMIT_TAG_MESSAGE', value: tag_message, public: true, masked: false }
2017-08-17 22:00:37 +05:30
end
before do
2020-11-24 15:15:51 +05:30
build.update!(tag: true)
pipeline.update!(tag: true)
2017-08-17 22:00:37 +05:30
end
2021-02-22 17:27:13 +05:30
it do
build.reload
2022-11-25 23:54:43 +05:30
expect(subject).to include(tag_variable, tag_message_variable)
2021-02-22 17:27:13 +05:30
end
2017-08-17 22:00:37 +05:30
end
2018-12-13 13:39:08 +05:30
context 'when CI variable is defined' do
let(:ci_variable) do
2019-07-07 11:18:12 +05:30
{ key: 'SECRET_KEY', value: 'secret_value', public: false, masked: false }
2017-08-17 22:00:37 +05:30
end
before do
2017-09-10 17:25:29 +05:30
create(:ci_variable,
2018-12-13 13:39:08 +05:30
ci_variable.slice(:key, :value).merge(project: project))
2017-08-17 22:00:37 +05:30
end
2018-12-13 13:39:08 +05:30
it { is_expected.to include(ci_variable) }
2017-09-10 17:25:29 +05:30
end
context 'when protected variable is defined' do
2019-01-03 12:48:30 +05:30
let(:ref) { Gitlab::Git::BRANCH_REF_PREFIX + build.ref }
2017-09-10 17:25:29 +05:30
let(:protected_variable) do
2019-07-07 11:18:12 +05:30
{ key: 'PROTECTED_KEY', value: 'protected_value', public: false, masked: false }
2017-09-10 17:25:29 +05:30
end
before do
create(:ci_variable,
:protected,
protected_variable.slice(:key, :value).merge(project: project))
end
context 'when the branch is protected' do
before do
2022-03-02 08:16:31 +05:30
allow(build.pipeline.project).to receive(:protected_for?).with(ref).and_return(true)
2017-09-10 17:25:29 +05:30
end
it { is_expected.to include(protected_variable) }
end
context 'when the tag is protected' do
before do
2022-03-02 08:16:31 +05:30
allow(build.pipeline.project).to receive(:protected_for?).with(ref).and_return(true)
2017-09-10 17:25:29 +05:30
end
it { is_expected.to include(protected_variable) }
end
context 'when the ref is not protected' do
it { is_expected.not_to include(protected_variable) }
end
end
2018-12-13 13:39:08 +05:30
context 'when group CI variable is defined' do
let(:ci_variable) do
2019-07-07 11:18:12 +05:30
{ key: 'SECRET_KEY', value: 'secret_value', public: false, masked: false }
2017-09-10 17:25:29 +05:30
end
before do
create(:ci_group_variable,
2018-12-13 13:39:08 +05:30
ci_variable.slice(:key, :value).merge(group: group))
2017-09-10 17:25:29 +05:30
end
2018-12-13 13:39:08 +05:30
it { is_expected.to include(ci_variable) }
2017-09-10 17:25:29 +05:30
end
context 'when group protected variable is defined' do
2019-01-03 12:48:30 +05:30
let(:ref) { Gitlab::Git::BRANCH_REF_PREFIX + build.ref }
2017-09-10 17:25:29 +05:30
let(:protected_variable) do
2019-07-07 11:18:12 +05:30
{ key: 'PROTECTED_KEY', value: 'protected_value', public: false, masked: false }
2017-09-10 17:25:29 +05:30
end
before do
create(:ci_group_variable,
:protected,
protected_variable.slice(:key, :value).merge(group: group))
end
context 'when the branch is protected' do
before do
2022-03-02 08:16:31 +05:30
allow(build.pipeline.project).to receive(:protected_for?).with(ref).and_return(true)
2017-09-10 17:25:29 +05:30
end
it { is_expected.to include(protected_variable) }
end
context 'when the tag is protected' do
before do
2022-03-02 08:16:31 +05:30
allow(build.pipeline.project).to receive(:protected_for?).with(ref).and_return(true)
2017-09-10 17:25:29 +05:30
end
it { is_expected.to include(protected_variable) }
end
context 'when the ref is not protected' do
2018-03-17 18:26:18 +05:30
before do
build.update_column(:ref, 'some/feature')
end
2017-09-10 17:25:29 +05:30
it { is_expected.not_to include(protected_variable) }
end
2017-08-17 22:00:37 +05:30
end
context 'when build is for triggers' do
let(:trigger) { create(:ci_trigger, project: project) }
2018-03-17 18:26:18 +05:30
let(:trigger_request) { create(:ci_trigger_request, pipeline: pipeline, trigger: trigger) }
2017-08-17 22:00:37 +05:30
let(:predefined_trigger_variable) do
2019-07-07 11:18:12 +05:30
{ key: 'CI_PIPELINE_TRIGGERED', value: 'true', public: true, masked: false }
2017-08-17 22:00:37 +05:30
end
before do
build.trigger_request = trigger_request
end
2022-08-13 15:12:31 +05:30
it { is_expected.to include(predefined_trigger_variable) }
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
context 'when pipeline has a variable' do
let!(:pipeline_variable) { create(:ci_pipeline_variable, pipeline: pipeline) }
2019-07-07 11:18:12 +05:30
it { is_expected.to include(key: pipeline_variable.key, value: pipeline_variable.value, public: false, masked: false) }
2017-09-10 17:25:29 +05:30
end
context 'when a job was triggered by a pipeline schedule' do
let(:pipeline_schedule) { create(:ci_pipeline_schedule, project: project) }
let!(:pipeline_schedule_variable) do
create(:ci_pipeline_schedule_variable,
2018-03-17 18:26:18 +05:30
key: 'SCHEDULE_VARIABLE_KEY',
pipeline_schedule: pipeline_schedule)
2017-09-10 17:25:29 +05:30
end
before do
2019-02-15 15:39:39 +05:30
pipeline_schedule.pipelines << pipeline.reload
2017-09-10 17:25:29 +05:30
pipeline_schedule.reload
end
2019-07-07 11:18:12 +05:30
it { is_expected.to include(key: pipeline_schedule_variable.key, value: pipeline_schedule_variable.value, public: false, masked: false) }
2017-09-10 17:25:29 +05:30
end
2017-08-17 22:00:37 +05:30
context 'when container registry is enabled' do
2021-10-27 15:23:28 +05:30
let_it_be_with_reload(:project) { create(:project, :public, :repository, group: group) }
let_it_be_with_reload(:pipeline) do
create(:ci_pipeline, project: project,
sha: project.commit.id,
ref: project.default_branch,
status: 'success')
end
let_it_be_with_refind(:build) { create(:ci_build, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
let(:container_registry_enabled) { true }
let(:ci_registry) do
2019-07-07 11:18:12 +05:30
{ key: 'CI_REGISTRY', value: 'registry.example.com', public: true, masked: false }
2017-08-17 22:00:37 +05:30
end
2020-10-24 23:57:45 +05:30
2017-08-17 22:00:37 +05:30
let(:ci_registry_image) do
2019-07-07 11:18:12 +05:30
{ key: 'CI_REGISTRY_IMAGE', value: project.container_registry_url, public: true, masked: false }
2017-08-17 22:00:37 +05:30
end
context 'and is disabled for project' do
before do
2021-10-27 15:23:28 +05:30
project.project_feature.update_column(:container_registry_access_level, ProjectFeature::DISABLED)
2017-08-17 22:00:37 +05:30
end
it { is_expected.to include(ci_registry) }
it { is_expected.not_to include(ci_registry_image) }
end
context 'and is enabled for project' do
before do
2021-10-27 15:23:28 +05:30
project.project_feature.update_column(:container_registry_access_level, ProjectFeature::ENABLED)
end
it { is_expected.to include(ci_registry) }
it { is_expected.to include(ci_registry_image) }
end
context 'and is private for project' do
before do
project.project_feature.update_column(:container_registry_access_level, ProjectFeature::PRIVATE)
2017-08-17 22:00:37 +05:30
end
it { is_expected.to include(ci_registry) }
it { is_expected.to include(ci_registry_image) }
end
end
context 'when runner is assigned to build' do
let(:runner) { create(:ci_runner, description: 'description', tag_list: %w(docker linux)) }
before do
2020-11-24 15:15:51 +05:30
build.update!(runner: runner)
2017-08-17 22:00:37 +05:30
end
2019-07-07 11:18:12 +05:30
it { is_expected.to include({ key: 'CI_RUNNER_ID', value: runner.id.to_s, public: true, masked: false }) }
it { is_expected.to include({ key: 'CI_RUNNER_DESCRIPTION', value: 'description', public: true, masked: false }) }
it { is_expected.to include({ key: 'CI_RUNNER_TAGS', value: 'docker, linux', public: true, masked: false }) }
2017-08-17 22:00:37 +05:30
end
context 'when build is for a deployment' do
2019-07-07 11:18:12 +05:30
let(:deployment_variable) { { key: 'KUBERNETES_TOKEN', value: 'TOKEN', public: false, masked: false } }
2017-08-17 22:00:37 +05:30
2016-09-29 09:46:39 +05:30
before do
2017-08-17 22:00:37 +05:30
build.environment = 'production'
2018-03-17 18:26:18 +05:30
allow_any_instance_of(Project)
.to receive(:deployment_variables)
.and_return([deployment_variable])
2016-09-29 09:46:39 +05:30
end
2017-08-17 22:00:37 +05:30
it { is_expected.to include(deployment_variable) }
2016-09-29 09:46:39 +05:30
end
2019-12-26 22:10:19 +05:30
context 'when project has default CI config path' do
let(:ci_config_path) { { key: 'CI_CONFIG_PATH', value: '.gitlab-ci.yml', public: true, masked: false } }
it { is_expected.to include(ci_config_path) }
end
2017-09-10 17:25:29 +05:30
context 'when project has custom CI config path' do
2019-07-07 11:18:12 +05:30
let(:ci_config_path) { { key: 'CI_CONFIG_PATH', value: 'custom', public: true, masked: false } }
2017-09-10 17:25:29 +05:30
before do
2021-03-08 18:12:59 +05:30
project.update!(ci_config_path: 'custom')
2017-09-10 17:25:29 +05:30
end
it { is_expected.to include(ci_config_path) }
end
2018-05-09 12:01:36 +05:30
context 'when pipeline variable overrides build variable' do
2021-02-22 17:27:13 +05:30
let(:build) do
create(:ci_build, pipeline: pipeline, yaml_variables: [{ key: 'MYVAR', value: 'myvar', public: true }])
end
2018-05-09 12:01:36 +05:30
before do
pipeline.variables.build(key: 'MYVAR', value: 'pipeline value')
end
it 'overrides YAML variable using a pipeline variable' do
2021-04-17 20:07:23 +05:30
variables = subject.to_runner_variables.reverse.uniq { |variable| variable[:key] }.reverse
2018-05-09 12:01:36 +05:30
expect(variables)
2019-07-07 11:18:12 +05:30
.not_to include(key: 'MYVAR', value: 'myvar', public: true, masked: false)
2018-05-09 12:01:36 +05:30
expect(variables)
2019-07-07 11:18:12 +05:30
.to include(key: 'MYVAR', value: 'pipeline value', public: false, masked: false)
2018-05-09 12:01:36 +05:30
end
end
2018-12-13 13:39:08 +05:30
context 'when build is parallelized' do
2020-10-24 23:57:45 +05:30
shared_examples 'parallelized jobs config' do
let(:index) { 3 }
let(:total) { 5 }
2018-12-13 13:39:08 +05:30
2020-10-24 23:57:45 +05:30
before do
build.options[:parallel] = config
build.options[:instance] = index
end
it 'includes CI_NODE_INDEX' do
is_expected.to include(
{ key: 'CI_NODE_INDEX', value: index.to_s, public: true, masked: false }
)
end
it 'includes correct CI_NODE_TOTAL' do
is_expected.to include(
{ key: 'CI_NODE_TOTAL', value: total.to_s, public: true, masked: false }
)
end
2018-12-13 13:39:08 +05:30
end
2020-10-24 23:57:45 +05:30
context 'when parallel is a number' do
let(:config) { 5 }
it_behaves_like 'parallelized jobs config'
2018-12-13 13:39:08 +05:30
end
2020-10-24 23:57:45 +05:30
context 'when parallel is hash with the total key' do
let(:config) { { total: 5 } }
it_behaves_like 'parallelized jobs config'
end
context 'when parallel is nil' do
let(:config) {}
it_behaves_like 'parallelized jobs config' do
let(:total) { 1 }
end
2018-12-13 13:39:08 +05:30
end
end
2018-05-09 12:01:36 +05:30
context 'when build has not been persisted yet' do
let(:build) do
described_class.new(
name: 'rspec',
stage: 'test',
ref: 'feature',
project: project,
pipeline: pipeline
)
end
2019-07-07 11:18:12 +05:30
let(:pipeline) { create(:ci_pipeline, project: project, ref: 'feature') }
2018-05-09 12:01:36 +05:30
it 'returns static predefined variables' do
expect(build.variables.size).to be >= 28
expect(build.variables)
2019-07-07 11:18:12 +05:30
.to include(key: 'CI_COMMIT_REF_NAME', value: 'feature', public: true, masked: false)
2018-05-09 12:01:36 +05:30
expect(build).not_to be_persisted
end
end
2018-10-15 14:42:47 +05:30
context 'for deploy tokens' do
let(:deploy_token) { create(:deploy_token, :gitlab_deploy_token) }
let(:deploy_token_variables) do
[
2019-07-07 11:18:12 +05:30
{ key: 'CI_DEPLOY_USER', value: deploy_token.username, public: true, masked: false },
{ key: 'CI_DEPLOY_PASSWORD', value: deploy_token.token, public: false, masked: true }
2018-10-15 14:42:47 +05:30
]
end
2022-07-23 23:45:48 +05:30
context 'when gitlab-deploy-token exists for project' do
2018-10-15 14:42:47 +05:30
before do
project.deploy_tokens << deploy_token
end
2019-07-07 11:18:12 +05:30
it 'includes deploy token variables' do
2018-10-15 14:42:47 +05:30
is_expected.to include(*deploy_token_variables)
end
end
2022-07-23 23:45:48 +05:30
context 'when gitlab-deploy-token does not exist for project' do
2019-07-07 11:18:12 +05:30
it 'does not include deploy token variables' do
2022-08-27 11:52:29 +05:30
expect(subject.find { |v| v[:key] == 'CI_DEPLOY_USER' }).to be_nil
expect(subject.find { |v| v[:key] == 'CI_DEPLOY_PASSWORD' }).to be_nil
2018-10-15 14:42:47 +05:30
end
2022-07-23 23:45:48 +05:30
context 'when gitlab-deploy-token exists for group' do
before do
group.deploy_tokens << deploy_token
end
it 'includes deploy token variables' do
is_expected.to include(*deploy_token_variables)
end
end
2018-10-15 14:42:47 +05:30
end
2022-05-07 20:08:51 +05:30
end
context 'for harbor integration' do
let(:harbor_integration) { create(:harbor_integration) }
let(:harbor_variables) do
[
{ key: 'HARBOR_URL', value: harbor_integration.url, public: true, masked: false },
{ key: 'HARBOR_PROJECT', value: harbor_integration.project_name, public: true, masked: false },
{ key: 'HARBOR_USERNAME', value: harbor_integration.username, public: true, masked: false },
{ key: 'HARBOR_PASSWORD', value: harbor_integration.password, public: false, masked: true }
]
end
context 'when harbor_integration exists' do
before do
build.project.update!(harbor_integration: harbor_integration)
end
it 'includes harbor variables' do
is_expected.to include(*harbor_variables)
end
end
context 'when harbor_integration does not exist' do
it 'does not include harbor variables' do
2022-08-27 11:52:29 +05:30
expect(subject.find { |v| v[:key] == 'HARBOR_URL' }).to be_nil
expect(subject.find { |v| v[:key] == 'HARBOR_PROJECT_NAME' }).to be_nil
expect(subject.find { |v| v[:key] == 'HARBOR_USERNAME' }).to be_nil
expect(subject.find { |v| v[:key] == 'HARBOR_PASSWORD' }).to be_nil
2022-05-07 20:08:51 +05:30
end
end
2018-10-15 14:42:47 +05:30
end
2020-05-24 23:13:21 +05:30
context 'when build has dependency which has dotenv variable' do
let!(:prepare) { create(:ci_build, pipeline: pipeline, stage_idx: 0) }
let!(:build) { create(:ci_build, pipeline: pipeline, stage_idx: 1, options: { dependencies: [prepare.name] }) }
let!(:job_variable) { create(:ci_job_variable, :dotenv_source, job: prepare) }
it { is_expected.to include(key: job_variable.key, value: job_variable.value, public: false, masked: false) }
end
2022-11-25 23:54:43 +05:30
context 'when ID tokens are defined on the build' do
before do
rsa_key = OpenSSL::PKey::RSA.generate(3072).to_s
stub_application_setting(ci_jwt_signing_key: rsa_key)
build.metadata.update!(id_tokens: {
'ID_TOKEN_1' => { id_token: { aud: 'developers' } },
'ID_TOKEN_2' => { id_token: { aud: 'maintainers' } }
})
end
subject(:runner_vars) { build.variables.to_runner_variables }
it 'includes the ID token variables' do
expect(runner_vars).to include(
a_hash_including(key: 'ID_TOKEN_1', public: false, masked: true),
a_hash_including(key: 'ID_TOKEN_2', public: false, masked: true)
)
id_token_var_1 = runner_vars.find { |var| var[:key] == 'ID_TOKEN_1' }
id_token_var_2 = runner_vars.find { |var| var[:key] == 'ID_TOKEN_2' }
id_token_1 = JWT.decode(id_token_var_1[:value], nil, false).first
id_token_2 = JWT.decode(id_token_var_2[:value], nil, false).first
expect(id_token_1['aud']).to eq('developers')
expect(id_token_2['aud']).to eq('maintainers')
end
context 'when a NoSigningKeyError is raised' do
it 'does not include the ID token variables' do
allow(::Gitlab::Ci::JwtV2).to receive(:for_build).and_raise(::Gitlab::Ci::Jwt::NoSigningKeyError)
expect(runner_vars.map { |var| var[:key] }).not_to include('ID_TOKEN_1', 'ID_TOKEN_2')
end
end
context 'when a RSAError is raised' do
it 'does not include the ID token variables' do
allow(::Gitlab::Ci::JwtV2).to receive(:for_build).and_raise(::OpenSSL::PKey::RSAError)
expect(runner_vars.map { |var| var[:key] }).not_to include('ID_TOKEN_1', 'ID_TOKEN_2')
end
end
end
2018-05-09 12:01:36 +05:30
end
describe '#scoped_variables' do
2021-12-11 22:18:48 +05:30
it 'records a prometheus metric' do
histogram = double(:histogram)
expect(::Gitlab::Ci::Pipeline::Metrics).to receive(:pipeline_builder_scoped_variables_histogram)
.and_return(histogram)
2019-07-07 11:18:12 +05:30
2021-12-11 22:18:48 +05:30
expect(histogram).to receive(:observe)
.with({}, a_kind_of(ActiveSupport::Duration))
2018-05-09 12:01:36 +05:30
2021-12-11 22:18:48 +05:30
build.scoped_variables
end
2018-05-09 12:01:36 +05:30
2021-12-11 22:18:48 +05:30
shared_examples 'calculates scoped_variables' do
context 'when build has not been persisted yet' do
let(:build) do
described_class.new(
name: 'rspec',
stage: 'test',
ref: 'feature',
project: project,
pipeline: pipeline,
scheduling_type: :stage
)
end
2018-05-09 12:01:36 +05:30
2021-12-11 22:18:48 +05:30
let(:pipeline) { create(:ci_pipeline, project: project, ref: 'feature') }
2018-05-09 12:01:36 +05:30
2021-12-11 22:18:48 +05:30
it 'does not persist the build' do
expect(build).to be_valid
expect(build).not_to be_persisted
2018-05-09 12:01:36 +05:30
2021-12-11 22:18:48 +05:30
build.scoped_variables
expect(build).not_to be_persisted
2018-05-09 12:01:36 +05:30
end
2021-12-11 22:18:48 +05:30
it 'returns static predefined variables' do
keys = %w[CI_JOB_NAME
CI_COMMIT_SHA
CI_COMMIT_SHORT_SHA
CI_COMMIT_REF_NAME
CI_COMMIT_REF_SLUG
CI_JOB_STAGE]
variables = build.scoped_variables
variables.map { |env| env[:key] }.tap do |names|
expect(names).to include(*keys)
end
expect(variables)
.to include(key: 'CI_COMMIT_REF_NAME', value: 'feature', public: true, masked: false)
end
it 'does not return prohibited variables' do
keys = %w[CI_JOB_ID
CI_JOB_URL
CI_JOB_TOKEN
CI_BUILD_ID
CI_BUILD_TOKEN
CI_REGISTRY_USER
CI_REGISTRY_PASSWORD
CI_REPOSITORY_URL
CI_ENVIRONMENT_URL
CI_DEPLOY_USER
CI_DEPLOY_PASSWORD]
build.scoped_variables.map { |env| env[:key] }.tap do |names|
expect(names).not_to include(*keys)
end
end
2018-05-09 12:01:36 +05:30
end
2021-12-11 22:18:48 +05:30
context 'with dependency variables' do
let!(:prepare) { create(:ci_build, name: 'prepare', pipeline: pipeline, stage_idx: 0) }
let!(:build) { create(:ci_build, pipeline: pipeline, stage_idx: 1, options: { dependencies: ['prepare'] }) }
let!(:job_variable) { create(:ci_job_variable, :dotenv_source, job: prepare) }
2018-05-09 12:01:36 +05:30
2021-12-11 22:18:48 +05:30
it 'inherits dependent variables' do
expect(build.scoped_variables.to_hash).to include(job_variable.key => job_variable.value)
2018-05-09 12:01:36 +05:30
end
end
end
2021-12-11 22:18:48 +05:30
it_behaves_like 'calculates scoped_variables'
2019-07-07 11:18:12 +05:30
2021-12-11 22:18:48 +05:30
it 'delegates to the variable builders' do
expect_next_instance_of(Gitlab::Ci::Variables::Builder) do |builder|
expect(builder)
.to receive(:scoped_variables).with(build, hash_including(:environment, :dependencies))
.and_call_original
2019-07-07 11:18:12 +05:30
2021-12-11 22:18:48 +05:30
expect(builder).to receive(:predefined_variables).and_call_original
2019-07-07 11:18:12 +05:30
end
2021-12-11 22:18:48 +05:30
build.scoped_variables
end
2019-07-07 11:18:12 +05:30
end
2020-10-24 23:57:45 +05:30
describe '#simple_variables_without_dependencies' do
it 'does not load dependencies' do
expect(build).not_to receive(:dependency_variables)
build.simple_variables_without_dependencies
end
end
2019-07-07 11:18:12 +05:30
describe '#any_unmet_prerequisites?' do
let(:build) { create(:ci_build, :created) }
subject { build.any_unmet_prerequisites? }
2019-09-04 21:01:54 +05:30
before do
allow(build).to receive(:prerequisites).and_return(prerequisites)
end
2019-07-07 11:18:12 +05:30
context 'build has prerequisites' do
2019-09-04 21:01:54 +05:30
let(:prerequisites) { [double] }
2019-07-07 11:18:12 +05:30
it { is_expected.to be_truthy }
end
context 'build does not have prerequisites' do
2019-09-04 21:01:54 +05:30
let(:prerequisites) { [] }
2019-07-07 11:18:12 +05:30
it { is_expected.to be_falsey }
end
end
2018-11-18 11:00:15 +05:30
describe '#yaml_variables' do
2019-02-15 15:39:39 +05:30
let(:build) { create(:ci_build, pipeline: pipeline, yaml_variables: variables) }
let(:variables) do
[
{ 'key' => :VARIABLE, 'value' => 'my value' },
{ 'key' => 'VARIABLE2', 'value' => 'my value 2' }
]
end
shared_examples 'having consistent representation' do
it 'allows to access using symbols' do
expect(build.reload.yaml_variables.first[:key]).to eq('VARIABLE')
expect(build.reload.yaml_variables.first[:value]).to eq('my value')
expect(build.reload.yaml_variables.second[:key]).to eq('VARIABLE2')
expect(build.reload.yaml_variables.second[:value]).to eq('my value 2')
end
2018-11-18 11:00:15 +05:30
end
2021-10-27 15:23:28 +05:30
it_behaves_like 'having consistent representation'
2019-02-15 15:39:39 +05:30
2021-10-27 15:23:28 +05:30
it 'persist data in build metadata' do
expect(build.metadata.read_attribute(:config_variables)).not_to be_nil
2018-11-18 11:00:15 +05:30
end
2021-10-27 15:23:28 +05:30
it 'does not persist data in build' do
expect(build.read_attribute(:yaml_variables)).to be_nil
2018-11-18 11:00:15 +05:30
end
end
2020-05-24 23:13:21 +05:30
describe '#dependency_variables' do
subject { build.dependency_variables }
context 'when using dependencies' do
let!(:prepare1) { create(:ci_build, name: 'prepare1', pipeline: pipeline, stage_idx: 0) }
let!(:prepare2) { create(:ci_build, name: 'prepare2', pipeline: pipeline, stage_idx: 0) }
let!(:build) { create(:ci_build, pipeline: pipeline, stage_idx: 1, options: { dependencies: ['prepare1'] }) }
let!(:job_variable_1) { create(:ci_job_variable, :dotenv_source, job: prepare1) }
let!(:job_variable_2) { create(:ci_job_variable, job: prepare1) }
let!(:job_variable_3) { create(:ci_job_variable, :dotenv_source, job: prepare2) }
it 'inherits only dependent variables' do
expect(subject.to_hash).to eq(job_variable_1.key => job_variable_1.value)
end
end
context 'when using needs' do
let!(:prepare1) { create(:ci_build, name: 'prepare1', pipeline: pipeline, stage_idx: 0) }
let!(:prepare2) { create(:ci_build, name: 'prepare2', pipeline: pipeline, stage_idx: 0) }
let!(:prepare3) { create(:ci_build, name: 'prepare3', pipeline: pipeline, stage_idx: 0) }
let!(:build) { create(:ci_build, pipeline: pipeline, stage_idx: 1, scheduling_type: 'dag') }
let!(:build_needs_prepare1) { create(:ci_build_need, build: build, name: 'prepare1', artifacts: true) }
let!(:build_needs_prepare2) { create(:ci_build_need, build: build, name: 'prepare2', artifacts: false) }
let!(:job_variable_1) { create(:ci_job_variable, :dotenv_source, job: prepare1) }
let!(:job_variable_2) { create(:ci_job_variable, :dotenv_source, job: prepare2) }
let!(:job_variable_3) { create(:ci_job_variable, :dotenv_source, job: prepare3) }
it 'inherits only needs with artifacts variables' do
expect(subject.to_hash).to eq(job_variable_1.key => job_variable_1.value)
end
end
end
2019-07-07 11:18:12 +05:30
describe 'state transition: any => [:preparing]' do
let(:build) { create(:ci_build, :created) }
before do
allow(build).to receive(:prerequisites).and_return([double])
end
it 'queues BuildPrepareWorker' do
expect(Ci::BuildPrepareWorker).to receive(:perform_async).with(build.id)
build.enqueue
end
end
2022-03-02 08:16:31 +05:30
describe 'when the build is waiting for deployment approval' do
let(:build) { create(:ci_build, :manual, environment: 'production') }
before do
create(:deployment, :blocked, deployable: build)
end
it 'does not allow the build to be enqueued' do
expect { build.enqueue! }.to raise_error(StateMachines::InvalidTransition)
end
end
2017-09-10 17:25:29 +05:30
describe 'state transition: any => [:pending]' do
2017-08-17 22:00:37 +05:30
let(:build) { create(:ci_build, :created) }
it 'queues BuildQueueWorker' do
expect(BuildQueueWorker).to receive(:perform_async).with(build.id)
build.enqueue
2016-09-29 09:46:39 +05:30
end
2022-01-26 12:08:38 +05:30
2022-08-27 11:52:29 +05:30
it 'executes hooks' do
expect(build).to receive(:execute_hooks)
2022-01-26 12:08:38 +05:30
build.enqueue
end
2016-09-29 09:46:39 +05:30
end
2017-09-10 17:25:29 +05:30
2018-05-09 12:01:36 +05:30
describe 'state transition: pending: :running' do
let(:runner) { create(:ci_runner) }
let(:job) { create(:ci_build, :pending, runner: runner) }
before do
job.project.update_attribute(:build_timeout, 1800)
end
def run_job_without_exception
job.run!
rescue StateMachines::InvalidTransition
end
2020-01-01 13:55:28 +05:30
context 'for pipeline ref existence' do
it 'ensures pipeline ref creation' do
2022-07-16 23:28:13 +05:30
expect(job.pipeline).to receive(:ensure_persistent_ref).once.and_call_original
2020-01-01 13:55:28 +05:30
expect(job.pipeline.persistent_ref).to receive(:create).once
run_job_without_exception
end
2019-12-21 20:55:43 +05:30
2020-01-01 13:55:28 +05:30
it 'ensures that it is not run in database transaction' do
expect(job.pipeline.persistent_ref).to receive(:create) do
2021-12-11 22:18:48 +05:30
expect(ApplicationRecord).not_to be_inside_transaction
2020-01-01 13:55:28 +05:30
end
run_job_without_exception
end
2019-12-21 20:55:43 +05:30
end
2018-05-09 12:01:36 +05:30
shared_examples 'saves data on transition' do
it 'saves timeout' do
expect { job.run! }.to change { job.reload.ensure_metadata.timeout }.from(nil).to(expected_timeout)
end
it 'saves timeout_source' do
expect { job.run! }.to change { job.reload.ensure_metadata.timeout_source }.from('unknown_timeout_source').to(expected_timeout_source)
end
context 'when Ci::BuildMetadata#update_timeout_state fails update' do
before do
allow_any_instance_of(Ci::BuildMetadata).to receive(:update_timeout_state).and_return(false)
end
it "doesn't save timeout" do
2020-04-22 19:07:51 +05:30
expect { run_job_without_exception }.not_to change { job.reload.ensure_metadata.timeout }
2018-05-09 12:01:36 +05:30
end
it "doesn't save timeout_source" do
expect { run_job_without_exception }.not_to change { job.reload.ensure_metadata.timeout_source }
end
end
end
context 'when runner timeout overrides project timeout' do
let(:expected_timeout) { 900 }
let(:expected_timeout_source) { 'runner_timeout_source' }
before do
runner.update_attribute(:maximum_timeout, 900)
end
it_behaves_like 'saves data on transition'
end
context "when runner timeout doesn't override project timeout" do
let(:expected_timeout) { 1800 }
let(:expected_timeout_source) { 'project_timeout_source' }
before do
runner.update_attribute(:maximum_timeout, 3600)
end
it_behaves_like 'saves data on transition'
end
end
2018-11-18 11:00:15 +05:30
describe '#has_valid_build_dependencies?' do
2018-03-17 18:26:18 +05:30
shared_examples 'validation is active' do
context 'when depended job has not been completed yet' do
let!(:pre_stage_job) { create(:ci_build, :manual, pipeline: pipeline, name: 'test', stage_idx: 0) }
2018-11-18 11:00:15 +05:30
it { expect(job).to have_valid_build_dependencies }
2018-03-17 18:26:18 +05:30
end
context 'when artifacts of depended job has been expired' do
let!(:pre_stage_job) { create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0) }
2021-10-27 15:23:28 +05:30
context 'when pipeline is not locked' do
before do
build.pipeline.unlocked!
end
it { expect(job).not_to have_valid_build_dependencies }
end
context 'when pipeline is locked' do
before do
build.pipeline.artifacts_locked!
end
it { expect(job).to have_valid_build_dependencies }
end
2018-03-17 18:26:18 +05:30
end
context 'when artifacts of depended job has been erased' do
let!(:pre_stage_job) { create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0, erased_at: 1.minute.ago) }
2018-11-18 11:00:15 +05:30
it { expect(job).not_to have_valid_build_dependencies }
2018-03-17 18:26:18 +05:30
end
end
shared_examples 'validation is not active' do
context 'when depended job has not been completed yet' do
let!(:pre_stage_job) { create(:ci_build, :manual, pipeline: pipeline, name: 'test', stage_idx: 0) }
2018-11-18 11:00:15 +05:30
it { expect(job).to have_valid_build_dependencies }
2018-03-17 18:26:18 +05:30
end
2018-11-18 11:00:15 +05:30
2018-03-17 18:26:18 +05:30
context 'when artifacts of depended job has been expired' do
let!(:pre_stage_job) { create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0) }
2018-11-18 11:00:15 +05:30
it { expect(job).to have_valid_build_dependencies }
2018-03-17 18:26:18 +05:30
end
context 'when artifacts of depended job has been erased' do
let!(:pre_stage_job) { create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0, erased_at: 1.minute.ago) }
2018-11-18 11:00:15 +05:30
it { expect(job).to have_valid_build_dependencies }
2018-03-17 18:26:18 +05:30
end
end
let!(:job) { create(:ci_build, :pending, pipeline: pipeline, stage_idx: 1, options: options) }
2021-06-08 01:23:25 +05:30
let!(:pre_stage_job) { create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0) }
2018-03-17 18:26:18 +05:30
2021-06-08 01:23:25 +05:30
context 'when "dependencies" keyword is not defined' do
let(:options) { {} }
2018-03-17 18:26:18 +05:30
2021-06-08 01:23:25 +05:30
it { expect(job).to have_valid_build_dependencies }
end
2018-03-17 18:26:18 +05:30
2021-06-08 01:23:25 +05:30
context 'when "dependencies" keyword is empty' do
let(:options) { { dependencies: [] } }
2018-03-17 18:26:18 +05:30
2021-06-08 01:23:25 +05:30
it { expect(job).to have_valid_build_dependencies }
2018-03-17 18:26:18 +05:30
end
2021-06-08 01:23:25 +05:30
context 'when "dependencies" keyword is specified' do
2018-03-17 18:26:18 +05:30
let(:options) { { dependencies: ['test'] } }
2021-06-08 01:23:25 +05:30
it_behaves_like 'validation is active'
2018-03-17 18:26:18 +05:30
end
end
2017-09-10 17:25:29 +05:30
describe 'state transition when build fails' do
2021-06-08 01:23:25 +05:30
let(:service) { ::MergeRequests::AddTodoWhenBuildFailsService.new(project: project, current_user: user) }
2018-03-17 18:26:18 +05:30
before do
2021-04-29 21:17:54 +05:30
allow(::MergeRequests::AddTodoWhenBuildFailsService).to receive(:new).and_return(service)
2018-03-17 18:26:18 +05:30
allow(service).to receive(:close)
end
2017-09-10 17:25:29 +05:30
context 'when build is configured to be retried' do
2019-02-15 15:39:39 +05:30
subject { create(:ci_build, :running, options: { script: ["ls -al"], retry: 3 }, project: project, user: user) }
2017-09-10 17:25:29 +05:30
2018-03-17 18:26:18 +05:30
it 'retries build and assigns the same user to it' do
2022-06-21 17:19:12 +05:30
expect_next_instance_of(::Ci::RetryJobService) do |service|
expect(service).to receive(:execute).with(subject)
end
2018-03-17 18:26:18 +05:30
subject.drop!
end
it 'does not try to create a todo' do
project.add_developer(user)
2019-07-07 11:18:12 +05:30
expect(service).not_to receive(:pipeline_merge_requests)
2017-09-10 17:25:29 +05:30
subject.drop!
end
2018-04-04 21:44:52 +05:30
context 'when retry service raises Gitlab::Access::AccessDeniedError exception' do
2022-06-21 17:19:12 +05:30
let(:retry_service) { Ci::RetryJobService.new(subject.project, subject.user) }
2018-04-04 21:44:52 +05:30
before do
2022-06-21 17:19:12 +05:30
allow_any_instance_of(Ci::RetryJobService)
2018-04-04 21:44:52 +05:30
.to receive(:execute)
.with(subject)
.and_raise(Gitlab::Access::AccessDeniedError)
2020-06-23 00:09:42 +05:30
allow(Gitlab::AppLogger).to receive(:error)
2018-04-04 21:44:52 +05:30
end
it 'handles raised exception' do
2021-02-22 17:27:13 +05:30
expect { subject.drop! }.not_to raise_error
2018-04-04 21:44:52 +05:30
end
it 'logs the error' do
subject.drop!
2020-06-23 00:09:42 +05:30
expect(Gitlab::AppLogger)
2018-04-04 21:44:52 +05:30
.to have_received(:error)
.with(a_string_matching("Unable to auto-retry job #{subject.id}"))
end
it 'fails the job' do
subject.drop!
expect(subject.failed?).to be_truthy
end
end
2017-09-10 17:25:29 +05:30
end
context 'when build is not configured to be retried' do
2019-07-07 11:18:12 +05:30
subject { create(:ci_build, :running, project: project, user: user, pipeline: pipeline) }
let(:pipeline) do
create(:ci_pipeline,
project: project,
ref: 'feature',
sha: merge_request.diff_head_sha,
merge_requests_as_head_pipeline: [merge_request])
end
let(:merge_request) do
create(:merge_request, :opened,
source_branch: 'feature',
source_project: project,
target_branch: 'master',
target_project: project)
end
2017-09-10 17:25:29 +05:30
it 'does not retry build' do
expect(described_class).not_to receive(:retry)
subject.drop!
end
it 'does not count retries when not necessary' do
expect(described_class).not_to receive(:retry)
expect_any_instance_of(described_class)
.not_to receive(:retries_count)
subject.drop!
end
2018-03-17 18:26:18 +05:30
2021-04-29 21:17:54 +05:30
it 'creates a todo async', :sidekiq_inline do
2018-03-17 18:26:18 +05:30
project.add_developer(user)
2019-07-07 11:18:12 +05:30
expect_next_instance_of(TodoService) do |todo_service|
expect(todo_service)
.to receive(:merge_request_build_failed).with(merge_request)
end
2018-03-17 18:26:18 +05:30
subject.drop!
end
end
2019-02-15 15:39:39 +05:30
context 'when associated deployment failed to update its status' do
let(:build) { create(:ci_build, :running, pipeline: pipeline) }
let!(:deployment) { create(:deployment, deployable: build) }
before do
allow_any_instance_of(Deployment)
.to receive(:drop!).and_raise('Unexpected error')
end
it 'can drop the build' do
2021-11-18 22:05:49 +05:30
expect(Gitlab::ErrorTracking).to receive(:track_exception)
2019-02-15 15:39:39 +05:30
expect { build.drop! }.not_to raise_error
expect(build).to be_failed
end
end
2018-03-17 18:26:18 +05:30
end
describe '.matches_tag_ids' do
2020-03-13 15:44:24 +05:30
let_it_be(:build, reload: true) { create(:ci_build, project: project, user: user) }
2021-04-29 21:17:54 +05:30
2018-03-17 18:26:18 +05:30
let(:tag_ids) { ::ActsAsTaggableOn::Tag.named_any(tag_list).ids }
subject { described_class.where(id: build).matches_tag_ids(tag_ids) }
before do
2020-11-24 15:15:51 +05:30
build.update!(tag_list: build_tag_list)
2018-03-17 18:26:18 +05:30
end
context 'when have different tags' do
let(:build_tag_list) { %w(A B) }
let(:tag_list) { %w(C D) }
it "does not match a build" do
is_expected.not_to contain_exactly(build)
end
end
context 'when have a subset of tags' do
let(:build_tag_list) { %w(A B) }
let(:tag_list) { %w(A B C D) }
it "does match a build" do
is_expected.to contain_exactly(build)
end
end
context 'when build does not have tags' do
let(:build_tag_list) { [] }
let(:tag_list) { %w(C D) }
it "does match a build" do
is_expected.to contain_exactly(build)
end
end
context 'when does not have a subset of tags' do
let(:build_tag_list) { %w(A B C) }
let(:tag_list) { %w(C D) }
it "does not match a build" do
is_expected.not_to contain_exactly(build)
end
end
end
describe '.matches_tags' do
2020-03-13 15:44:24 +05:30
let_it_be(:build, reload: true) { create(:ci_build, project: project, user: user) }
2018-03-17 18:26:18 +05:30
subject { described_class.where(id: build).with_any_tags }
before do
2020-11-24 15:15:51 +05:30
build.update!(tag_list: tag_list)
2018-03-17 18:26:18 +05:30
end
context 'when does have tags' do
let(:tag_list) { %w(A B) }
it "does match a build" do
is_expected.to contain_exactly(build)
end
end
context 'when does not have tags' do
let(:tag_list) { [] }
it "does not match a build" do
is_expected.not_to contain_exactly(build)
end
2017-09-10 17:25:29 +05:30
end
end
2018-11-08 19:23:39 +05:30
describe 'pages deployments' do
2020-03-13 15:44:24 +05:30
let_it_be(:build, reload: true) { create(:ci_build, project: project, user: user) }
2018-11-08 19:23:39 +05:30
context 'when job is "pages"' do
before do
build.name = 'pages'
end
context 'when pages are enabled' do
before do
allow(Gitlab.config.pages).to receive_messages(enabled: true)
end
it 'is marked as pages generator' do
expect(build).to be_pages_generator
end
context 'job succeeds' do
it "calls pages worker" do
expect(PagesWorker).to receive(:perform_async).with(:deploy, build.id)
build.success!
end
end
context 'job fails' do
it "does not call pages worker" do
expect(PagesWorker).not_to receive(:perform_async)
build.drop!
end
end
end
context 'when pages are disabled' do
before do
allow(Gitlab.config.pages).to receive_messages(enabled: false)
end
it 'is not marked as pages generator' do
expect(build).not_to be_pages_generator
end
context 'job succeeds' do
it "does not call pages worker" do
expect(PagesWorker).not_to receive(:perform_async)
build.success!
end
end
end
end
context 'when job is not "pages"' do
before do
build.name = 'other-job'
end
it 'is not marked as pages generator' do
expect(build).not_to be_pages_generator
end
context 'job succeeds' do
it "does not call pages worker" do
expect(PagesWorker).not_to receive(:perform_async)
build.success
end
end
end
end
describe '#has_terminal?' do
let(:states) { described_class.state_machines[:status].states.keys - [:running] }
subject { build.has_terminal? }
it 'returns true if the build is running and it has a runner_session_url' do
build.build_runner_session(url: 'whatever')
build.status = :running
expect(subject).to be_truthy
end
context 'returns false' do
it 'when runner_session_url is empty' do
build.status = :running
expect(subject).to be_falsey
end
context 'unless the build is running' do
before do
build.build_runner_session(url: 'whatever')
end
it do
states.each do |state|
build.status = state
is_expected.to be_falsey
end
end
end
end
end
2018-11-18 11:00:15 +05:30
describe '#collect_test_reports!' do
2022-10-11 01:57:18 +05:30
subject(:test_reports) { build.collect_test_reports!(Gitlab::Ci::Reports::TestReport.new) }
2018-11-18 11:00:15 +05:30
it { expect(test_reports.get_suite(build.name).total_count).to eq(0) }
context 'when build has a test report' do
context 'when there is a JUnit test report from rspec test suite' do
before do
create(:ci_job_artifact, :junit, job: build, project: build.project)
end
it 'parses blobs and add the results to the test suite' do
expect { subject }.not_to raise_error
expect(test_reports.get_suite(build.name).total_count).to eq(4)
expect(test_reports.get_suite(build.name).success_count).to be(2)
expect(test_reports.get_suite(build.name).failed_count).to be(2)
end
end
context 'when there is a JUnit test report from java ant test suite' do
before do
create(:ci_job_artifact, :junit_with_ant, job: build, project: build.project)
end
it 'parses blobs and add the results to the test suite' do
expect { subject }.not_to raise_error
expect(test_reports.get_suite(build.name).total_count).to eq(3)
expect(test_reports.get_suite(build.name).success_count).to be(3)
expect(test_reports.get_suite(build.name).failed_count).to be(0)
end
end
context 'when there is a corrupted JUnit test report' do
before do
create(:ci_job_artifact, :junit_with_corrupted_data, job: build, project: build.project)
end
2020-05-24 23:13:21 +05:30
it 'returns no test data and includes a suite_error message' do
expect { subject }.not_to raise_error
expect(test_reports.get_suite(build.name).total_count).to eq(0)
expect(test_reports.get_suite(build.name).success_count).to eq(0)
expect(test_reports.get_suite(build.name).failed_count).to eq(0)
expect(test_reports.get_suite(build.name).suite_error).to eq('JUnit XML parsing failed: 1:1: FATAL: Document is empty')
end
end
end
end
describe '#collect_accessibility_reports!' do
subject { build.collect_accessibility_reports!(accessibility_report) }
let(:accessibility_report) { Gitlab::Ci::Reports::AccessibilityReports.new }
it { expect(accessibility_report.urls).to eq({}) }
context 'when build has an accessibility report' do
context 'when there is an accessibility report with errors' do
before do
create(:ci_job_artifact, :accessibility, job: build, project: build.project)
end
it 'parses blobs and add the results to the accessibility report' do
expect { subject }.not_to raise_error
expect(accessibility_report.urls.keys).to match_array(['https://about.gitlab.com/'])
expect(accessibility_report.errors_count).to eq(10)
expect(accessibility_report.scans_count).to eq(1)
expect(accessibility_report.passes_count).to eq(0)
end
end
context 'when there is an accessibility report without errors' do
before do
create(:ci_job_artifact, :accessibility_without_errors, job: build, project: build.project)
end
it 'parses blobs and add the results to the accessibility report' do
expect { subject }.not_to raise_error
expect(accessibility_report.urls.keys).to match_array(['https://pa11y.org/'])
expect(accessibility_report.errors_count).to eq(0)
expect(accessibility_report.scans_count).to eq(1)
expect(accessibility_report.passes_count).to eq(1)
end
end
context 'when there is an accessibility report with an invalid url' do
before do
create(:ci_job_artifact, :accessibility_with_invalid_url, job: build, project: build.project)
end
it 'parses blobs and add the results to the accessibility report' do
expect { subject }.not_to raise_error
expect(accessibility_report.urls).to be_empty
expect(accessibility_report.errors_count).to eq(0)
expect(accessibility_report.scans_count).to eq(0)
expect(accessibility_report.passes_count).to eq(0)
2018-11-18 11:00:15 +05:30
end
end
end
end
2021-02-22 17:27:13 +05:30
describe '#collect_codequality_reports!' do
subject(:codequality_report) { build.collect_codequality_reports!(Gitlab::Ci::Reports::CodequalityReports.new) }
it { expect(codequality_report.degradations).to eq({}) }
context 'when build has a codequality report' do
context 'when there is a codequality report' do
before do
create(:ci_job_artifact, :codequality, job: build, project: build.project)
end
it 'parses blobs and add the results to the codequality report' do
expect { codequality_report }.not_to raise_error
expect(codequality_report.degradations_count).to eq(3)
end
end
context 'when there is an codequality report without errors' do
before do
create(:ci_job_artifact, :codequality_without_errors, job: build, project: build.project)
end
it 'parses blobs and add the results to the codequality report' do
expect { codequality_report }.not_to raise_error
expect(codequality_report.degradations_count).to eq(0)
2020-04-08 14:13:33 +05:30
end
end
end
end
2020-05-24 23:13:21 +05:30
describe '#collect_terraform_reports!' do
let(:terraform_reports) { Gitlab::Ci::Reports::TerraformReports.new }
it 'returns an empty hash' do
expect(build.collect_terraform_reports!(terraform_reports).plans).to eq({})
end
context 'when build has a terraform report' do
context 'when there is a valid tfplan.json' do
before do
create(:ci_job_artifact, :terraform, job: build, project: build.project)
end
it 'parses blobs and add the results to the terraform report' do
expect { build.collect_terraform_reports!(terraform_reports) }.not_to raise_error
2020-07-28 23:09:34 +05:30
terraform_reports.plans.each do |key, hash_value|
expect(hash_value.keys).to match_array(%w[create delete job_id job_name job_path update])
end
2020-05-24 23:13:21 +05:30
expect(terraform_reports.plans).to match(
a_hash_including(
2020-06-23 00:09:42 +05:30
build.id.to_s => a_hash_including(
2020-05-24 23:13:21 +05:30
'create' => 0,
'update' => 1,
2020-06-23 00:09:42 +05:30
'delete' => 0,
2022-01-26 12:08:38 +05:30
'job_name' => build.name
2020-05-24 23:13:21 +05:30
)
)
)
end
end
context 'when there is an invalid tfplan.json' do
before do
create(:ci_job_artifact, :terraform_with_corrupted_data, job: build, project: build.project)
end
2020-07-28 23:09:34 +05:30
it 'adds invalid plan report' do
expect { build.collect_terraform_reports!(terraform_reports) }.not_to raise_error
terraform_reports.plans.each do |key, hash_value|
expect(hash_value.keys).to match_array(%w[job_id job_name job_path tf_report_error])
end
expect(terraform_reports.plans).to match(
a_hash_including(
build.id.to_s => a_hash_including(
'tf_report_error' => :invalid_json_format
)
)
2020-05-24 23:13:21 +05:30
)
end
end
end
end
2022-07-23 23:45:48 +05:30
describe '#each_report' do
2022-08-27 11:52:29 +05:30
let(:report_types) { Ci::JobArtifact.file_types_for_report(:coverage) }
2022-07-23 23:45:48 +05:30
let!(:codequality) { create(:ci_job_artifact, :codequality, job: build) }
let!(:coverage) { create(:ci_job_artifact, :coverage_gocov_xml, job: build) }
let!(:junit) { create(:ci_job_artifact, :junit, job: build) }
it 'yields job artifact blob that matches the type' do
expect { |b| build.each_report(report_types, &b) }.to yield_with_args(coverage.file_type, String, coverage)
end
end
2019-09-04 21:01:54 +05:30
describe '#report_artifacts' do
subject { build.report_artifacts }
context 'when the build has reports' do
let!(:report) { create(:ci_job_artifact, :codequality, job: build) }
it 'returns the artifacts with reports' do
expect(subject).to contain_exactly(report)
end
end
end
2018-11-18 11:00:15 +05:30
describe '#artifacts_metadata_entry' do
2020-03-13 15:44:24 +05:30
let_it_be(:build) { create(:ci_build, project: project) }
2021-04-29 21:17:54 +05:30
2018-11-18 11:00:15 +05:30
let(:path) { 'other_artifacts_0.1.2/another-subdirectory/banana_sample.gif' }
2020-03-13 15:44:24 +05:30
around do |example|
2020-11-24 15:15:51 +05:30
freeze_time { example.run }
2020-03-13 15:44:24 +05:30
end
2018-11-18 11:00:15 +05:30
before do
2022-08-27 11:52:29 +05:30
allow(build).to receive(:execute_hooks)
2018-11-18 11:00:15 +05:30
stub_artifacts_object_storage
end
subject { build.artifacts_metadata_entry(path) }
context 'when using local storage' do
let!(:metadata) { create(:ci_job_artifact, :metadata, job: build) }
context 'for existing file' do
it 'does exist' do
is_expected.to be_exists
end
end
context 'for non-existing file' do
let(:path) { 'invalid-file' }
it 'does not exist' do
is_expected.not_to be_exists
end
end
end
context 'when using remote storage' do
include HttpIOHelpers
let!(:metadata) { create(:ci_job_artifact, :remote_store, :metadata, job: build) }
let(:file_path) { expand_fixture_path('ci_build_artifacts_metadata.gz') }
before do
stub_remote_url_206(metadata.file.url, file_path)
end
context 'for existing file' do
it 'does exist' do
is_expected.to be_exists
end
end
context 'for non-existing file' do
let(:path) { 'invalid-file' }
it 'does not exist' do
is_expected.not_to be_exists
end
end
end
end
describe '#publishes_artifacts_reports?' do
let(:build) { create(:ci_build, options: options) }
subject { build.publishes_artifacts_reports? }
context 'when artifacts reports are defined' do
let(:options) do
{ artifacts: { reports: { junit: "junit.xml" } } }
end
it { is_expected.to be_truthy }
end
context 'when artifacts reports missing defined' do
let(:options) do
{ artifacts: { paths: ["file.txt"] } }
end
it { is_expected.to be_falsey }
end
context 'when options are missing' do
let(:options) { nil }
it { is_expected.to be_falsey }
end
end
describe '#runner_required_feature_names' do
let(:build) { create(:ci_build, options: options) }
subject { build.runner_required_feature_names }
context 'when artifacts reports are defined' do
let(:options) do
{ artifacts: { reports: { junit: "junit.xml" } } }
end
it { is_expected.to include(:upload_multiple_artifacts) }
end
2020-05-24 23:13:21 +05:30
2021-09-30 23:02:18 +05:30
context 'when artifacts exclude is defined' do
2020-05-24 23:13:21 +05:30
let(:options) do
{ artifacts: { exclude: %w[something] } }
end
2021-09-30 23:02:18 +05:30
it { is_expected.to include(:artifacts_exclude) }
2020-05-24 23:13:21 +05:30
end
2018-11-18 11:00:15 +05:30
end
describe '#supported_runner?' do
2021-03-08 18:12:59 +05:30
let_it_be_with_refind(:build) { create(:ci_build) }
2018-11-18 11:00:15 +05:30
subject { build.supported_runner?(runner_features) }
2020-06-23 00:09:42 +05:30
context 'when `upload_multiple_artifacts` feature is required by build' do
2018-11-18 11:00:15 +05:30
before do
expect(build).to receive(:runner_required_feature_names) do
[:upload_multiple_artifacts]
end
end
context 'when runner provides given feature' do
let(:runner_features) do
{ upload_multiple_artifacts: true }
end
it { is_expected.to be_truthy }
end
context 'when runner does not provide given feature' do
let(:runner_features) do
{}
end
it { is_expected.to be_falsey }
end
end
2019-07-07 11:18:12 +05:30
2020-06-23 00:09:42 +05:30
context 'when `refspecs` feature is required by build' do
2019-07-07 11:18:12 +05:30
before do
allow(build).to receive(:merge_request_ref?) { true }
end
context 'when runner provides given feature' do
let(:runner_features) { { refspecs: true } }
it { is_expected.to be_truthy }
end
2020-06-23 00:09:42 +05:30
context 'when runner does not provide given feature' do
let(:runner_features) { {} }
it { is_expected.to be_falsey }
end
end
2020-07-28 23:09:34 +05:30
context 'when `multi_build_steps` feature is required by build' do
2020-06-23 00:09:42 +05:30
before do
expect(build).to receive(:runner_required_feature_names) do
2020-07-28 23:09:34 +05:30
[:multi_build_steps]
2020-06-23 00:09:42 +05:30
end
end
context 'when runner provides given feature' do
2020-07-28 23:09:34 +05:30
let(:runner_features) { { multi_build_steps: true } }
2020-06-23 00:09:42 +05:30
it { is_expected.to be_truthy }
end
2019-07-07 11:18:12 +05:30
context 'when runner does not provide given feature' do
let(:runner_features) { {} }
it { is_expected.to be_falsey }
end
end
2021-03-08 18:12:59 +05:30
context 'when `return_exit_code` feature is required by build' do
let(:options) { { allow_failure_criteria: { exit_codes: [1] } } }
before do
build.update!(options: options)
end
context 'when runner provides given feature' do
let(:runner_features) { { return_exit_code: true } }
it { is_expected.to be_truthy }
end
context 'when runner does not provide given feature' do
let(:runner_features) { {} }
it { is_expected.to be_falsey }
end
context 'when the runner does not provide all of the required features' do
let(:options) do
{
allow_failure_criteria: { exit_codes: [1] },
artifacts: { reports: { junit: "junit.xml" } }
}
end
let(:runner_features) { { return_exit_code: true } }
it 'requires `upload_multiple_artifacts` too' do
is_expected.to be_falsey
end
end
end
2018-11-18 11:00:15 +05:30
end
2018-12-05 23:21:45 +05:30
describe '#deployment_status' do
2018-12-13 13:39:08 +05:30
before do
allow_any_instance_of(described_class).to receive(:create_deployment)
end
2018-12-05 23:21:45 +05:30
context 'when build is a last deployment' do
2020-03-13 15:44:24 +05:30
let(:build) { create(:ci_build, :success, environment: 'production', pipeline: pipeline, project: project) }
2018-12-05 23:21:45 +05:30
let(:environment) { create(:environment, name: 'production', project: build.project) }
2018-12-13 13:39:08 +05:30
let!(:deployment) { create(:deployment, :success, environment: environment, project: environment.project, deployable: build) }
2018-12-05 23:21:45 +05:30
it { expect(build.deployment_status).to eq(:last) }
end
context 'when there is a newer build with deployment' do
2020-03-13 15:44:24 +05:30
let(:build) { create(:ci_build, :success, environment: 'production', pipeline: pipeline, project: project) }
2018-12-05 23:21:45 +05:30
let(:environment) { create(:environment, name: 'production', project: build.project) }
2018-12-13 13:39:08 +05:30
let!(:deployment) { create(:deployment, :success, environment: environment, project: environment.project, deployable: build) }
let!(:last_deployment) { create(:deployment, :success, environment: environment, project: environment.project) }
2018-12-05 23:21:45 +05:30
it { expect(build.deployment_status).to eq(:out_of_date) }
end
context 'when build with deployment has failed' do
2020-03-13 15:44:24 +05:30
let(:build) { create(:ci_build, :failed, environment: 'production', pipeline: pipeline, project: project) }
2018-12-05 23:21:45 +05:30
let(:environment) { create(:environment, name: 'production', project: build.project) }
2018-12-13 13:39:08 +05:30
let!(:deployment) { create(:deployment, :success, environment: environment, project: environment.project, deployable: build) }
2018-12-05 23:21:45 +05:30
it { expect(build.deployment_status).to eq(:failed) }
end
context 'when build with deployment is running' do
2020-03-13 15:44:24 +05:30
let(:build) { create(:ci_build, environment: 'production', pipeline: pipeline, project: project) }
2018-12-05 23:21:45 +05:30
let(:environment) { create(:environment, name: 'production', project: build.project) }
2018-12-13 13:39:08 +05:30
let!(:deployment) { create(:deployment, :success, environment: environment, project: environment.project, deployable: build) }
2018-12-05 23:21:45 +05:30
it { expect(build.deployment_status).to eq(:creating) }
end
2018-12-13 13:39:08 +05:30
end
2018-12-05 23:21:45 +05:30
2018-12-13 13:39:08 +05:30
describe '#degenerated?' do
context 'when build is degenerated' do
subject { create(:ci_build, :degenerated) }
2018-12-05 23:21:45 +05:30
2018-12-13 13:39:08 +05:30
it { is_expected.to be_degenerated }
end
context 'when build is valid' do
subject { create(:ci_build) }
it { is_expected.not_to be_degenerated }
context 'and becomes degenerated' do
before do
subject.degenerate!
end
it { is_expected.to be_degenerated }
end
end
end
2019-02-15 15:39:39 +05:30
describe 'degenerate!' do
let(:build) { create(:ci_build) }
subject { build.degenerate! }
before do
build.ensure_metadata
2019-10-12 21:52:04 +05:30
build.needs.create!(name: 'another-job')
2019-02-15 15:39:39 +05:30
end
it 'drops metadata' do
subject
expect(build.reload).to be_degenerated
expect(build.metadata).to be_nil
2019-10-12 21:52:04 +05:30
expect(build.needs).to be_empty
2019-02-15 15:39:39 +05:30
end
end
2018-12-13 13:39:08 +05:30
describe '#archived?' do
context 'when build is degenerated' do
subject { create(:ci_build, :degenerated) }
it { is_expected.to be_archived }
end
context 'for old build' do
subject { create(:ci_build, created_at: 1.day.ago) }
context 'when archive_builds_in is set' do
before do
stub_application_setting(archive_builds_in_seconds: 3600)
end
it { is_expected.to be_archived }
end
context 'when archive_builds_in is not set' do
before do
stub_application_setting(archive_builds_in_seconds: nil)
end
it { is_expected.not_to be_archived }
end
2018-12-05 23:21:45 +05:30
end
end
2019-02-15 15:39:39 +05:30
describe '#read_metadata_attribute' do
let(:build) { create(:ci_build, :degenerated) }
2021-09-30 23:02:18 +05:30
let(:build_options) { { key: "build" } }
let(:metadata_options) { { key: "metadata" } }
let(:default_options) { { key: "default" } }
2019-02-15 15:39:39 +05:30
subject { build.send(:read_metadata_attribute, :options, :config_options, default_options) }
context 'when build and metadata options is set' do
before do
build.write_attribute(:options, build_options)
build.ensure_metadata.write_attribute(:config_options, metadata_options)
end
it 'prefers build options' do
is_expected.to eq(build_options)
end
end
context 'when only metadata options is set' do
before do
build.write_attribute(:options, nil)
build.ensure_metadata.write_attribute(:config_options, metadata_options)
end
it 'returns metadata options' do
is_expected.to eq(metadata_options)
end
end
context 'when none is set' do
it 'returns default value' do
is_expected.to eq(default_options)
end
end
end
describe '#write_metadata_attribute' do
let(:build) { create(:ci_build, :degenerated) }
2021-09-30 23:02:18 +05:30
let(:options) { { key: "new options" } }
let(:existing_options) { { key: "existing options" } }
2019-02-15 15:39:39 +05:30
subject { build.send(:write_metadata_attribute, :options, :config_options, options) }
2021-10-27 15:23:28 +05:30
context 'when data in build is already set' do
2019-02-15 15:39:39 +05:30
before do
2021-10-27 15:23:28 +05:30
build.write_attribute(:options, existing_options)
2019-02-15 15:39:39 +05:30
end
2021-10-27 15:23:28 +05:30
it 'does set metadata options' do
subject
2019-02-15 15:39:39 +05:30
2021-10-27 15:23:28 +05:30
expect(build.metadata.read_attribute(:config_options)).to eq(options)
2019-02-15 15:39:39 +05:30
end
2021-10-27 15:23:28 +05:30
it 'does reset build options' do
subject
2019-02-15 15:39:39 +05:30
2021-10-27 15:23:28 +05:30
expect(build.read_attribute(:options)).to be_nil
2019-02-15 15:39:39 +05:30
end
end
end
2019-12-21 20:55:43 +05:30
describe '#invalid_dependencies' do
let!(:pre_stage_job_valid) { create(:ci_build, :manual, pipeline: pipeline, name: 'test1', stage_idx: 0) }
let!(:pre_stage_job_invalid) { create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test2', stage_idx: 1) }
let!(:job) { create(:ci_build, :pending, pipeline: pipeline, stage_idx: 2, options: { dependencies: %w(test1 test2) }) }
2021-10-27 15:23:28 +05:30
context 'when pipeline is locked' do
before do
build.pipeline.unlocked!
end
it 'returns invalid dependencies when expired' do
expect(job.invalid_dependencies).to eq([pre_stage_job_invalid])
end
end
context 'when pipeline is not locked' do
before do
build.pipeline.artifacts_locked!
end
it 'returns no invalid dependencies when expired' do
expect(job.invalid_dependencies).to eq([])
end
2019-12-21 20:55:43 +05:30
end
end
2020-01-01 13:55:28 +05:30
describe '#execute_hooks' do
2021-06-08 01:23:25 +05:30
before do
build.clear_memoization(:build_data)
end
2020-01-01 13:55:28 +05:30
context 'with project hooks' do
2021-06-08 01:23:25 +05:30
let(:build_data) { double(:BuildData, dup: double(:DupedData)) }
2020-01-01 13:55:28 +05:30
before do
create(:project_hook, project: project, job_events: true)
end
2021-06-08 01:23:25 +05:30
it 'calls project.execute_hooks(build_data, :job_hooks)' do
expect(::Gitlab::DataBuilder::Build)
.to receive(:build).with(build).and_return(build_data)
expect(build.project)
.to receive(:execute_hooks).with(build_data.dup, :job_hooks)
2020-01-01 13:55:28 +05:30
build.execute_hooks
end
2022-07-23 23:45:48 +05:30
context 'with blocked users' do
before do
allow(build).to receive(:user) { FactoryBot.build(:user, :blocked) }
end
it 'does not call project.execute_hooks' do
expect(build.project).not_to receive(:execute_hooks)
build.execute_hooks
end
end
2020-01-01 13:55:28 +05:30
end
2021-06-08 01:23:25 +05:30
context 'without project hooks' do
it 'does not call project.execute_hooks' do
expect(build.project).not_to receive(:execute_hooks)
2020-01-01 13:55:28 +05:30
build.execute_hooks
end
end
context 'with project services' do
before do
2021-09-04 01:27:46 +05:30
create(:integration, active: true, job_events: true, project: project)
2020-01-01 13:55:28 +05:30
end
2021-06-08 01:23:25 +05:30
it 'executes services' do
allow_next_found_instance_of(Integration) do |integration|
expect(integration).to receive(:async_execute)
end
2020-01-01 13:55:28 +05:30
build.execute_hooks
end
end
context 'without relevant project services' do
before do
2021-09-04 01:27:46 +05:30
create(:integration, active: true, job_events: false, project: project)
2020-01-01 13:55:28 +05:30
end
2021-06-08 01:23:25 +05:30
it 'does not execute services' do
allow_next_found_instance_of(Integration) do |integration|
expect(integration).not_to receive(:async_execute)
end
2020-01-01 13:55:28 +05:30
build.execute_hooks
end
end
end
describe '#environment_auto_stop_in' do
subject { build.environment_auto_stop_in }
context 'when build option has environment auto_stop_in' do
let(:build) { create(:ci_build, options: { environment: { name: 'test', auto_stop_in: '1 day' } }) }
it { is_expected.to eq('1 day') }
end
context 'when build option does not have environment auto_stop_in' do
let(:build) { create(:ci_build) }
it { is_expected.to be_nil }
end
end
2020-05-24 23:13:21 +05:30
describe '#degradation_threshold' do
subject { build.degradation_threshold }
context 'when threshold variable is defined' do
before do
build.yaml_variables = [
{ key: 'SOME_VAR_1', value: 'SOME_VAL_1' },
{ key: 'DEGRADATION_THRESHOLD', value: '5' },
{ key: 'SOME_VAR_2', value: 'SOME_VAL_2' }
]
end
it { is_expected.to eq(5) }
end
context 'when threshold variable is not defined' do
before do
build.yaml_variables = [
{ key: 'SOME_VAR_1', value: 'SOME_VAL_1' },
{ key: 'SOME_VAR_2', value: 'SOME_VAL_2' }
]
end
it { is_expected.to be_nil }
end
end
2021-01-03 14:25:43 +05:30
describe '#run_on_status_commit' do
it 'runs provided hook after status commit' do
action = spy('action')
build.run_on_status_commit { action.perform! }
build.success!
expect(action).to have_received(:perform!).once
end
it 'does not run hooks when status has not changed' do
action = spy('action')
build.run_on_status_commit { action.perform! }
build.save!
expect(action).not_to have_received(:perform!)
end
end
2021-02-22 17:27:13 +05:30
describe '#debug_mode?' do
subject { build.debug_mode? }
context 'when CI_DEBUG_TRACE=true is in variables' do
context 'when in instance variables' do
before do
create(:ci_instance_variable, key: 'CI_DEBUG_TRACE', value: 'true')
end
it { is_expected.to eq true }
end
context 'when in group variables' do
before do
create(:ci_group_variable, key: 'CI_DEBUG_TRACE', value: 'true', group: project.group)
end
it { is_expected.to eq true }
end
context 'when in pipeline variables' do
before do
create(:ci_pipeline_variable, key: 'CI_DEBUG_TRACE', value: 'true', pipeline: pipeline)
end
it { is_expected.to eq true }
end
context 'when in project variables' do
before do
create(:ci_variable, key: 'CI_DEBUG_TRACE', value: 'true', project: project)
end
it { is_expected.to eq true }
end
context 'when in job variables' do
before do
create(:ci_job_variable, key: 'CI_DEBUG_TRACE', value: 'true', job: build)
end
it { is_expected.to eq true }
end
context 'when in yaml variables' do
before do
build.update!(yaml_variables: [{ key: :CI_DEBUG_TRACE, value: 'true' }])
end
it { is_expected.to eq true }
end
end
context 'when CI_DEBUG_TRACE is not in variables' do
it { is_expected.to eq false }
end
end
2021-03-08 18:12:59 +05:30
describe '#drop_with_exit_code!' do
let(:exit_code) { 1 }
let(:options) { {} }
before do
build.options.merge!(options)
build.save!
end
subject(:drop_with_exit_code) do
build.drop_with_exit_code!(:unknown_failure, exit_code)
end
shared_examples 'drops the build without changing allow_failure' do
it 'does not change allow_failure' do
expect { drop_with_exit_code }
.not_to change { build.reload.allow_failure }
end
it 'drops the build' do
expect { drop_with_exit_code }
.to change { build.reload.failed? }
end
end
context 'when exit_codes are not defined' do
it_behaves_like 'drops the build without changing allow_failure'
end
context 'when allow_failure_criteria is nil' do
let(:options) { { allow_failure_criteria: nil } }
it_behaves_like 'drops the build without changing allow_failure'
end
context 'when exit_codes is nil' do
let(:options) do
{
allow_failure_criteria: {
exit_codes: nil
}
}
end
it_behaves_like 'drops the build without changing allow_failure'
end
context 'when exit_codes do not match' do
let(:options) do
{
allow_failure_criteria: {
exit_codes: [2, 3, 4]
}
}
end
it_behaves_like 'drops the build without changing allow_failure'
end
context 'with matching exit codes' do
let(:options) do
{ allow_failure_criteria: { exit_codes: [1, 2, 3] } }
end
it 'changes allow_failure' do
expect { drop_with_exit_code }
.to change { build.reload.allow_failure }
end
it 'drops the build' do
expect { drop_with_exit_code }
.to change { build.reload.failed? }
end
context 'when exit_code is nil' do
let(:exit_code) {}
it_behaves_like 'drops the build without changing allow_failure'
end
end
2022-03-02 08:16:31 +05:30
context 'when build is configured to be retried' do
let(:options) { { retry: 3 } }
context 'when there is an MR attached to the pipeline and a failed job todo for that MR' do
let!(:merge_request) { create(:merge_request, source_project: project, author: user, head_pipeline: pipeline) }
let!(:todo) { create(:todo, :build_failed, user: user, project: project, author: user, target: merge_request) }
before do
build.update!(user: user)
project.add_developer(user)
end
it 'resolves the todo for the old failed build' do
expect do
drop_with_exit_code
end.to change { todo.reload.state }.from('pending').to('done')
end
end
end
2021-03-08 18:12:59 +05:30
end
describe '#exit_codes_defined?' do
let(:options) { {} }
before do
build.options.merge!(options)
end
subject(:exit_codes_defined) do
build.exit_codes_defined?
end
context 'without allow_failure_criteria' do
it { is_expected.to be_falsey }
end
context 'when exit_codes is nil' do
let(:options) do
{
allow_failure_criteria: {
exit_codes: nil
}
}
end
it { is_expected.to be_falsey }
end
context 'when exit_codes is an empty array' do
let(:options) do
{
allow_failure_criteria: {
exit_codes: []
}
}
end
it { is_expected.to be_falsey }
end
context 'when exit_codes are defined' do
let(:options) do
{
allow_failure_criteria: {
exit_codes: [5, 6]
}
}
end
it { is_expected.to be_truthy }
end
end
2021-09-04 01:27:46 +05:30
describe '.build_matchers' do
let_it_be(:pipeline) { create(:ci_pipeline, :protected) }
subject(:matchers) { pipeline.builds.build_matchers(pipeline.project) }
context 'when the pipeline is empty' do
it 'does not throw errors' do
is_expected.to eq([])
end
end
context 'when the pipeline has builds' do
let_it_be(:build_without_tags) do
create(:ci_build, pipeline: pipeline)
end
let_it_be(:build_with_tags) do
create(:ci_build, pipeline: pipeline, tag_list: %w[tag1 tag2])
end
let_it_be(:other_build_with_tags) do
create(:ci_build, pipeline: pipeline, tag_list: %w[tag2 tag1])
end
it { expect(matchers.size).to eq(2) }
it 'groups build ids' do
2022-11-25 23:54:43 +05:30
expect(matchers.map(&:build_ids)).to match_array(
[
[build_without_tags.id],
match_array([build_with_tags.id, other_build_with_tags.id])
])
2021-09-04 01:27:46 +05:30
end
it { expect(matchers.map(&:tag_list)).to match_array([[], %w[tag1 tag2]]) }
it { expect(matchers.map(&:protected?)).to all be_falsey }
context 'when the builds are protected' do
before do
pipeline.builds.update_all(protected: true)
end
it { expect(matchers).to all be_protected }
end
end
end
describe '#build_matcher' do
let_it_be(:build) do
build_stubbed(:ci_build, tag_list: %w[tag1 tag2])
end
subject(:matcher) { build.build_matcher }
it { expect(matcher.build_ids).to eq([build.id]) }
it { expect(matcher.tag_list).to match_array(%w[tag1 tag2]) }
it { expect(matcher.protected?).to eq(build.protected?) }
it { expect(matcher.project).to eq(build.project) }
end
describe '#shared_runner_build?' do
context 'when build does not have a runner assigned' do
it 'is not a shared runner build' do
expect(build.runner).to be_nil
expect(build).not_to be_shared_runner_build
end
end
context 'when build has a project runner assigned' do
before do
build.runner = create(:ci_runner, :project)
end
it 'is not a shared runner build' do
expect(build).not_to be_shared_runner_build
end
end
context 'when build has an instance runner assigned' do
before do
build.runner = create(:ci_runner, :instance_type)
end
it 'is a shared runner build' do
expect(build).to be_shared_runner_build
end
end
end
2021-10-27 15:23:28 +05:30
describe '.with_project_and_metadata' do
it 'does not join across databases' do
with_cross_joins_prevented do
::Ci::Build.with_project_and_metadata.to_a
end
end
end
2021-09-04 01:27:46 +05:30
describe '.without_coverage' do
let!(:build_with_coverage) { create(:ci_build, pipeline: pipeline, coverage: 100.0) }
it 'returns builds without coverage values' do
expect(described_class.without_coverage).to eq([build])
end
end
describe '.with_coverage_regex' do
let!(:build_with_coverage_regex) { create(:ci_build, pipeline: pipeline, coverage_regex: '\d') }
it 'returns builds with coverage regex values' do
expect(described_class.with_coverage_regex).to eq([build_with_coverage_regex])
end
end
2021-11-11 11:23:49 +05:30
describe '#ensure_trace_metadata!' do
it 'delegates to Ci::BuildTraceMetadata' do
expect(Ci::BuildTraceMetadata)
.to receive(:find_or_upsert_for!)
.with(build.id)
build.ensure_trace_metadata!
end
end
describe '#doom!' do
subject { build.doom! }
2022-03-02 08:16:31 +05:30
let(:traits) { [] }
let(:build) { create(:ci_build, *traits, pipeline: pipeline) }
2021-11-11 11:23:49 +05:30
it 'updates status and failure_reason', :aggregate_failures do
subject
expect(build.status).to eq("failed")
expect(build.failure_reason).to eq("data_integrity_failure")
end
2022-03-02 08:16:31 +05:30
it 'logs a message' do
expect(Gitlab::AppLogger)
.to receive(:info)
.with(a_hash_including(message: 'Build doomed', class: build.class.name, build_id: build.id))
.and_call_original
2021-11-11 11:23:49 +05:30
subject
2022-03-02 08:16:31 +05:30
end
2022-07-23 23:45:48 +05:30
context 'with deployment' do
let(:environment) { create(:environment) }
let(:build) { create(:ci_build, :with_deployment, environment: environment.name, pipeline: pipeline) }
it 'updates the deployment status', :aggregate_failures do
expect(build.deployment).to receive(:sync_status_with).with(build).and_call_original
subject
expect(build.deployment.reload.status).to eq("failed")
end
end
2022-03-02 08:16:31 +05:30
context 'with queued builds' do
let(:traits) { [:queued] }
it 'drops associated pending build' do
subject
2021-11-11 11:23:49 +05:30
2022-03-02 08:16:31 +05:30
expect(build.reload.queuing_entry).not_to be_present
end
end
context 'with running builds' do
let(:traits) { [:picked] }
it 'drops associated runtime metadata' do
subject
expect(build.reload.runtime_metadata).not_to be_present
end
2021-11-11 11:23:49 +05:30
end
end
2021-11-18 22:05:49 +05:30
it 'does not generate cross DB queries when a record is created via FactoryBot' do
with_cross_database_modification_prevented do
create(:ci_build)
end
end
2021-12-11 22:18:48 +05:30
2022-10-11 01:57:18 +05:30
describe '#runtime_runner_features' do
2021-12-11 22:18:48 +05:30
subject do
build.save!
build.cancel_gracefully?
end
2022-08-27 11:52:29 +05:30
let(:build) { create(:ci_build, pipeline: pipeline) }
2021-12-11 22:18:48 +05:30
it 'cannot cancel gracefully' do
expect(subject).to be false
end
it 'can cancel gracefully' do
build.set_cancel_gracefully
expect(subject).to be true
end
end
2022-01-26 12:08:38 +05:30
it_behaves_like 'it has loose foreign keys' do
let(:factory_name) { :ci_build }
end
it_behaves_like 'cleanup by a loose foreign key' do
let!(:model) { create(:ci_build, user: create(:user)) }
let!(:parent) { model.user }
end
2022-08-27 11:52:29 +05:30
describe '#clone' do
2022-11-25 23:54:43 +05:30
let_it_be(:user) { create(:user) }
2022-08-27 11:52:29 +05:30
context 'when given new job variables' do
context 'when the cloned build has an action' do
it 'applies the new job variables' do
build = create(:ci_build, :actionable)
create(:ci_job_variable, job: build, key: 'TEST_KEY', value: 'old value')
create(:ci_job_variable, job: build, key: 'OLD_KEY', value: 'i will not live for long')
2022-11-25 23:54:43 +05:30
new_build = build.clone(current_user: user, new_job_variables_attributes:
[
{ key: 'TEST_KEY', value: 'new value' },
{ key: 'NEW_KEY', value: 'exciting new value' }
])
2022-08-27 11:52:29 +05:30
new_build.save!
expect(new_build.job_variables.count).to be(2)
expect(new_build.job_variables.pluck(:key)).to contain_exactly('TEST_KEY', 'NEW_KEY')
expect(new_build.job_variables.map(&:value)).to contain_exactly('new value', 'exciting new value')
end
end
context 'when the cloned build does not have an action' do
it 'applies the old job variables' do
build = create(:ci_build)
create(:ci_job_variable, job: build, key: 'TEST_KEY', value: 'old value')
2022-11-25 23:54:43 +05:30
new_build = build.clone(
current_user: user,
new_job_variables_attributes: [{ key: 'TEST_KEY', value: 'new value' }]
)
2022-08-27 11:52:29 +05:30
new_build.save!
expect(new_build.job_variables.count).to be(1)
expect(new_build.job_variables.pluck(:key)).to contain_exactly('TEST_KEY')
expect(new_build.job_variables.map(&:value)).to contain_exactly('old value')
end
end
end
context 'when not given new job variables' do
it 'applies the old job variables' do
build = create(:ci_build)
create(:ci_job_variable, job: build, key: 'TEST_KEY', value: 'old value')
new_build = build.clone(current_user: user)
new_build.save!
expect(new_build.job_variables.count).to be(1)
expect(new_build.job_variables.pluck(:key)).to contain_exactly('TEST_KEY')
expect(new_build.job_variables.map(&:value)).to contain_exactly('old value')
end
end
end
2022-10-11 01:57:18 +05:30
describe '#test_suite_name' do
let(:build) { create(:ci_build, name: 'test') }
it 'uses the group name for test suite name' do
expect(build.test_suite_name).to eq('test')
end
context 'when build is part of parallel build' do
let(:build) { create(:ci_build, name: 'build 1/2') }
it 'uses the group name for test suite name' do
expect(build.test_suite_name).to eq('build')
end
end
context 'when build is part of matrix build' do
let!(:matrix_build) { create(:ci_build, :matrix) }
it 'uses the job name for the test suite' do
expect(matrix_build.test_suite_name).to eq(matrix_build.name)
end
end
end
end