721 lines
17 KiB
Ruby
721 lines
17 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
RSpec.describe Ci::ResetSkippedJobsService, :sidekiq_inline, feature_category: :continuous_integration do
|
|
let_it_be(:project) { create(:project, :empty_repo) }
|
|
let_it_be(:user) { project.first_owner }
|
|
|
|
let(:pipeline) do
|
|
Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
|
|
end
|
|
|
|
let(:a1) { find_job('a1') }
|
|
let(:a2) { find_job('a2') }
|
|
let(:b1) { find_job('b1') }
|
|
let(:input_processables) { a1 } # This is the input used when running service.execute()
|
|
|
|
before_all do
|
|
project.repository.create_file(user, 'init', 'init', message: 'init', branch_name: 'master')
|
|
end
|
|
|
|
subject(:service) { described_class.new(project, user) }
|
|
|
|
shared_examples 'with a stage-dag mixed pipeline' do
|
|
let(:config) do
|
|
<<-YAML
|
|
stages: [a, b, c]
|
|
|
|
a1:
|
|
stage: a
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
a2:
|
|
stage: a
|
|
script: exit 0
|
|
needs: [a1]
|
|
|
|
a3:
|
|
stage: a
|
|
script: exit 0
|
|
needs: [a2]
|
|
|
|
b1:
|
|
stage: b
|
|
script: exit 0
|
|
needs: []
|
|
|
|
b2:
|
|
stage: b
|
|
script: exit 0
|
|
needs: [a2]
|
|
|
|
c1:
|
|
stage: c
|
|
script: exit 0
|
|
needs: [b2]
|
|
|
|
c2:
|
|
stage: c
|
|
script: exit 0
|
|
YAML
|
|
end
|
|
|
|
before do
|
|
stub_ci_pipeline_yaml_file(config)
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
a3: 'created',
|
|
b1: 'pending',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
|
|
b1.success!
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
a3: 'created',
|
|
b1: 'success',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
|
|
a1.drop!
|
|
check_jobs_statuses(
|
|
a1: 'failed',
|
|
a2: 'skipped',
|
|
a3: 'skipped',
|
|
b1: 'success',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
|
|
new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
|
|
new_a1.enqueue!
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'skipped',
|
|
a3: 'skipped',
|
|
b1: 'success',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
end
|
|
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
service.execute(input_processables)
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
a3: 'created',
|
|
b1: 'success',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
end
|
|
|
|
context 'when executed by a different user than the original owner' do
|
|
let(:retryer) { create(:user).tap { |u| project.add_maintainer(u) } }
|
|
let(:service) { described_class.new(project, retryer) }
|
|
|
|
it 'reassigns jobs with updated statuses to the retryer' do
|
|
expect(jobs_name_status_owner_needs).to contain_exactly(
|
|
{ 'name' => 'a1', 'status' => 'pending', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'a2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a1'] },
|
|
{ 'name' => 'a3', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'b1', 'status' => 'success', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'b2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'c1', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['b2'] },
|
|
{ 'name' => 'c2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => [] }
|
|
)
|
|
|
|
service.execute(input_processables)
|
|
|
|
expect(jobs_name_status_owner_needs).to contain_exactly(
|
|
{ 'name' => 'a1', 'status' => 'pending', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'a2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a1'] },
|
|
{ 'name' => 'a3', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'b1', 'status' => 'success', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'b2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'c1', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['b2'] },
|
|
{ 'name' => 'c2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => [] }
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
shared_examples 'with stage-dag mixed pipeline with some same-stage needs' do
|
|
let(:config) do
|
|
<<-YAML
|
|
stages: [a, b, c]
|
|
|
|
a1:
|
|
stage: a
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
a2:
|
|
stage: a
|
|
script: exit 0
|
|
needs: [a1]
|
|
|
|
b1:
|
|
stage: b
|
|
script: exit 0
|
|
needs: [b2]
|
|
|
|
b2:
|
|
stage: b
|
|
script: exit 0
|
|
|
|
c1:
|
|
stage: c
|
|
script: exit 0
|
|
needs: [b2]
|
|
|
|
c2:
|
|
stage: c
|
|
script: exit 0
|
|
YAML
|
|
end
|
|
|
|
before do
|
|
stub_ci_pipeline_yaml_file(config)
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
b1: 'created',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
|
|
a1.drop!
|
|
check_jobs_statuses(
|
|
a1: 'failed',
|
|
a2: 'skipped',
|
|
b1: 'skipped',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
|
|
new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
|
|
new_a1.enqueue!
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'skipped',
|
|
b1: 'skipped',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
end
|
|
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
service.execute(input_processables)
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
b1: 'created',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
end
|
|
end
|
|
|
|
shared_examples 'with same-stage needs' do
|
|
let(:config) do
|
|
<<-YAML
|
|
a1:
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
b1:
|
|
script: exit 0
|
|
needs: [a1]
|
|
|
|
c1:
|
|
script: exit 0
|
|
needs: [b1]
|
|
YAML
|
|
end
|
|
|
|
before do
|
|
stub_ci_pipeline_yaml_file(config)
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
b1: 'created',
|
|
c1: 'created'
|
|
)
|
|
|
|
a1.drop!
|
|
check_jobs_statuses(
|
|
a1: 'failed',
|
|
b1: 'skipped',
|
|
c1: 'skipped'
|
|
)
|
|
|
|
new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
|
|
new_a1.enqueue!
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
b1: 'skipped',
|
|
c1: 'skipped'
|
|
)
|
|
end
|
|
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
service.execute(input_processables)
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
b1: 'created',
|
|
c1: 'created'
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'with same-stage needs where the parent jobs do not share the same descendants' do
|
|
let(:config) do
|
|
<<-YAML
|
|
a1:
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
a2:
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
b1:
|
|
script: exit 0
|
|
needs: [a1]
|
|
|
|
b2:
|
|
script: exit 0
|
|
needs: [a2]
|
|
|
|
c1:
|
|
script: exit 0
|
|
needs: [b1]
|
|
|
|
c2:
|
|
script: exit 0
|
|
needs: [b2]
|
|
YAML
|
|
end
|
|
|
|
before do
|
|
stub_ci_pipeline_yaml_file(config)
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'pending',
|
|
b1: 'created',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
|
|
a1.drop!
|
|
a2.drop!
|
|
|
|
check_jobs_statuses(
|
|
a1: 'failed',
|
|
a2: 'failed',
|
|
b1: 'skipped',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
|
|
new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
|
|
new_a1.enqueue!
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'failed',
|
|
b1: 'skipped',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
|
|
new_a2 = Ci::RetryJobService.new(project, user).clone!(a2)
|
|
new_a2.enqueue!
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'pending',
|
|
b1: 'skipped',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
end
|
|
|
|
# This demonstrates that when only a1 is inputted, only the *1 subsequent jobs are reset.
|
|
# This is in contrast to the following example when both a1 and a2 are inputted.
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
service.execute(input_processables)
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'pending',
|
|
b1: 'created',
|
|
b2: 'skipped',
|
|
c1: 'created',
|
|
c2: 'skipped'
|
|
)
|
|
end
|
|
|
|
context 'when multiple processables are inputted' do
|
|
# When both a1 and a2 are inputted, all subsequent jobs are reset.
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
input_processables = [a1, a2]
|
|
service.execute(input_processables)
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'pending',
|
|
b1: 'created',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when a single processable is inputted' do
|
|
it_behaves_like 'with a stage-dag mixed pipeline'
|
|
it_behaves_like 'with stage-dag mixed pipeline with some same-stage needs'
|
|
it_behaves_like 'with same-stage needs'
|
|
end
|
|
|
|
context 'when multiple processables are inputted' do
|
|
let(:input_processables) { [a1, b1] }
|
|
|
|
it_behaves_like 'with a stage-dag mixed pipeline'
|
|
it_behaves_like 'with stage-dag mixed pipeline with some same-stage needs'
|
|
it_behaves_like 'with same-stage needs'
|
|
end
|
|
|
|
context 'when FF is `ci_support_reset_skipped_jobs_for_multiple_jobs` disabled' do
|
|
before do
|
|
stub_feature_flags(ci_support_reset_skipped_jobs_for_multiple_jobs: false)
|
|
end
|
|
|
|
context 'with a stage-dag mixed pipeline' do
|
|
let(:config) do
|
|
<<-YAML
|
|
stages: [a, b, c]
|
|
|
|
a1:
|
|
stage: a
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
a2:
|
|
stage: a
|
|
script: exit 0
|
|
needs: [a1]
|
|
|
|
a3:
|
|
stage: a
|
|
script: exit 0
|
|
needs: [a2]
|
|
|
|
b1:
|
|
stage: b
|
|
script: exit 0
|
|
needs: []
|
|
|
|
b2:
|
|
stage: b
|
|
script: exit 0
|
|
needs: [a2]
|
|
|
|
c1:
|
|
stage: c
|
|
script: exit 0
|
|
needs: [b2]
|
|
|
|
c2:
|
|
stage: c
|
|
script: exit 0
|
|
YAML
|
|
end
|
|
|
|
let(:pipeline) do
|
|
Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
|
|
end
|
|
|
|
let(:a1) { find_job('a1') }
|
|
let(:b1) { find_job('b1') }
|
|
|
|
before do
|
|
stub_ci_pipeline_yaml_file(config)
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
a3: 'created',
|
|
b1: 'pending',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
|
|
b1.success!
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
a3: 'created',
|
|
b1: 'success',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
|
|
a1.drop!
|
|
check_jobs_statuses(
|
|
a1: 'failed',
|
|
a2: 'skipped',
|
|
a3: 'skipped',
|
|
b1: 'success',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
|
|
new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
|
|
new_a1.enqueue!
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'skipped',
|
|
a3: 'skipped',
|
|
b1: 'success',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
end
|
|
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
execute_after_requeue_service(a1)
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
a3: 'created',
|
|
b1: 'success',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
end
|
|
|
|
context 'when executed by a different user than the original owner' do
|
|
let(:retryer) { create(:user).tap { |u| project.add_maintainer(u) } }
|
|
let(:service) { described_class.new(project, retryer) }
|
|
|
|
it 'reassigns jobs with updated statuses to the retryer' do
|
|
expect(jobs_name_status_owner_needs).to contain_exactly(
|
|
{ 'name' => 'a1', 'status' => 'pending', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'a2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a1'] },
|
|
{ 'name' => 'a3', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'b1', 'status' => 'success', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'b2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'c1', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['b2'] },
|
|
{ 'name' => 'c2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => [] }
|
|
)
|
|
|
|
execute_after_requeue_service(a1)
|
|
|
|
expect(jobs_name_status_owner_needs).to contain_exactly(
|
|
{ 'name' => 'a1', 'status' => 'pending', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'a2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a1'] },
|
|
{ 'name' => 'a3', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'b1', 'status' => 'success', 'user_id' => user.id, 'needs' => [] },
|
|
{ 'name' => 'b2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a2'] },
|
|
{ 'name' => 'c1', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['b2'] },
|
|
{ 'name' => 'c2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => [] }
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'with stage-dag mixed pipeline with some same-stage needs' do
|
|
let(:config) do
|
|
<<-YAML
|
|
stages: [a, b, c]
|
|
|
|
a1:
|
|
stage: a
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
a2:
|
|
stage: a
|
|
script: exit 0
|
|
needs: [a1]
|
|
|
|
b1:
|
|
stage: b
|
|
script: exit 0
|
|
needs: [b2]
|
|
|
|
b2:
|
|
stage: b
|
|
script: exit 0
|
|
|
|
c1:
|
|
stage: c
|
|
script: exit 0
|
|
needs: [b2]
|
|
|
|
c2:
|
|
stage: c
|
|
script: exit 0
|
|
YAML
|
|
end
|
|
|
|
let(:pipeline) do
|
|
Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
|
|
end
|
|
|
|
let(:a1) { find_job('a1') }
|
|
|
|
before do
|
|
stub_ci_pipeline_yaml_file(config)
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
b1: 'created',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
|
|
a1.drop!
|
|
check_jobs_statuses(
|
|
a1: 'failed',
|
|
a2: 'skipped',
|
|
b1: 'skipped',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
|
|
new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
|
|
new_a1.enqueue!
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'skipped',
|
|
b1: 'skipped',
|
|
b2: 'skipped',
|
|
c1: 'skipped',
|
|
c2: 'skipped'
|
|
)
|
|
end
|
|
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
execute_after_requeue_service(a1)
|
|
|
|
check_jobs_statuses(
|
|
a1: 'pending',
|
|
a2: 'created',
|
|
b1: 'created',
|
|
b2: 'created',
|
|
c1: 'created',
|
|
c2: 'created'
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'with same-stage needs' do
|
|
let(:config) do
|
|
<<-YAML
|
|
a:
|
|
script: exit $(($RANDOM % 2))
|
|
|
|
b:
|
|
script: exit 0
|
|
needs: [a]
|
|
|
|
c:
|
|
script: exit 0
|
|
needs: [b]
|
|
YAML
|
|
end
|
|
|
|
let(:pipeline) do
|
|
Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
|
|
end
|
|
|
|
let(:a) { find_job('a') }
|
|
|
|
before do
|
|
stub_ci_pipeline_yaml_file(config)
|
|
check_jobs_statuses(
|
|
a: 'pending',
|
|
b: 'created',
|
|
c: 'created'
|
|
)
|
|
|
|
a.drop!
|
|
check_jobs_statuses(
|
|
a: 'failed',
|
|
b: 'skipped',
|
|
c: 'skipped'
|
|
)
|
|
|
|
new_a = Ci::RetryJobService.new(project, user).clone!(a)
|
|
new_a.enqueue!
|
|
check_jobs_statuses(
|
|
a: 'pending',
|
|
b: 'skipped',
|
|
c: 'skipped'
|
|
)
|
|
end
|
|
|
|
it 'marks subsequent skipped jobs as processable' do
|
|
execute_after_requeue_service(a)
|
|
|
|
check_jobs_statuses(
|
|
a: 'pending',
|
|
b: 'created',
|
|
c: 'created'
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def find_job(name)
|
|
processables.find_by!(name: name)
|
|
end
|
|
|
|
def check_jobs_statuses(statuses)
|
|
expect(processables.order(:name).pluck(:name, :status)).to contain_exactly(*statuses.stringify_keys.to_a)
|
|
end
|
|
|
|
def processables
|
|
pipeline.processables.latest
|
|
end
|
|
|
|
def jobs_name_status_owner_needs
|
|
processables.reload.map do |job|
|
|
job.attributes.slice('name', 'status', 'user_id').merge('needs' => job.needs.map(&:name))
|
|
end
|
|
end
|
|
|
|
# Remove this method when FF is `ci_support_reset_skipped_jobs_for_multiple_jobs` is removed
|
|
def execute_after_requeue_service(processable)
|
|
service.execute(processable)
|
|
end
|
|
end
|