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

941 lines
27 KiB
Ruby
Raw Normal View History

2019-07-07 11:18:12 +05:30
# frozen_string_literal: true
2015-09-25 12:07:36 +05:30
require 'spec_helper'
2020-07-28 23:09:34 +05:30
RSpec.describe Ci::Runner do
2019-02-15 15:39:39 +05:30
it_behaves_like 'having unique enum values'
2016-06-02 11:05:42 +05:30
describe 'validation' do
2018-03-17 18:26:18 +05:30
it { is_expected.to validate_presence_of(:access_level) }
2018-11-08 19:23:39 +05:30
it { is_expected.to validate_presence_of(:runner_type) }
2018-03-17 18:26:18 +05:30
2016-06-02 11:05:42 +05:30
context 'when runner is not allowed to pick untagged jobs' do
context 'when runner does not have tags' do
it 'is not valid' do
runner = build(:ci_runner, tag_list: [], run_untagged: false)
expect(runner).to be_invalid
end
end
context 'when runner has tags' do
it 'is valid' do
runner = build(:ci_runner, tag_list: ['tag'], run_untagged: false)
expect(runner).to be_valid
end
end
end
2018-10-15 14:42:47 +05:30
2020-03-13 15:44:24 +05:30
describe '#exactly_one_group' do
2018-10-15 14:42:47 +05:30
let(:group) { create(:group) }
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :group, groups: [group]) }
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
it 'disallows assigning group if already assigned to a group' do
2018-10-15 14:42:47 +05:30
runner.groups << build(:group)
expect(runner).not_to be_valid
2018-11-08 19:23:39 +05:30
expect(runner.errors.full_messages).to include('Runner needs to be assigned to exactly one group')
2018-10-15 14:42:47 +05:30
end
2018-11-08 19:23:39 +05:30
end
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
context 'runner_type validations' do
2020-03-13 15:44:24 +05:30
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project) }
2018-11-08 19:23:39 +05:30
let(:group_runner) { create(:ci_runner, :group, groups: [group]) }
let(:project_runner) { create(:ci_runner, :project, projects: [project]) }
let(:instance_runner) { create(:ci_runner, :instance) }
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
it 'disallows assigning group to project_type runner' do
project_runner.groups << build(:group)
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
expect(project_runner).not_to be_valid
expect(project_runner.errors.full_messages).to include('Runner cannot have groups assigned')
2018-10-15 14:42:47 +05:30
end
2018-11-08 19:23:39 +05:30
it 'disallows assigning group to instance_type runner' do
instance_runner.groups << build(:group)
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
expect(instance_runner).not_to be_valid
expect(instance_runner.errors.full_messages).to include('Runner cannot have groups assigned')
2018-10-15 14:42:47 +05:30
end
2018-11-08 19:23:39 +05:30
it 'disallows assigning project to group_type runner' do
group_runner.projects << build(:project)
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
expect(group_runner).not_to be_valid
expect(group_runner.errors.full_messages).to include('Runner cannot have projects assigned')
2018-10-15 14:42:47 +05:30
end
2018-11-08 19:23:39 +05:30
it 'disallows assigning project to instance_type runner' do
instance_runner.projects << build(:project)
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
expect(instance_runner).not_to be_valid
expect(instance_runner.errors.full_messages).to include('Runner cannot have projects assigned')
2018-10-15 14:42:47 +05:30
end
2019-07-07 11:18:12 +05:30
it 'fails to save a group assigned to a project runner even if the runner is already saved' do
2019-07-31 22:56:46 +05:30
group.runners << project_runner
expect { group.save! }
2018-11-08 19:23:39 +05:30
.to raise_error(ActiveRecord::RecordInvalid)
2018-10-15 14:42:47 +05:30
end
end
2020-04-22 19:07:51 +05:30
context 'cost factors validations' do
it 'dissalows :private_projects_minutes_cost_factor being nil' do
runner = build(:ci_runner, private_projects_minutes_cost_factor: nil)
expect(runner).to be_invalid
expect(runner.errors.full_messages).to include('Private projects minutes cost factor needs to be non-negative')
end
it 'dissalows :public_projects_minutes_cost_factor being nil' do
runner = build(:ci_runner, public_projects_minutes_cost_factor: nil)
expect(runner).to be_invalid
expect(runner.errors.full_messages).to include('Public projects minutes cost factor needs to be non-negative')
end
it 'dissalows :private_projects_minutes_cost_factor being negative' do
runner = build(:ci_runner, private_projects_minutes_cost_factor: -1.1)
expect(runner).to be_invalid
expect(runner.errors.full_messages).to include('Private projects minutes cost factor needs to be non-negative')
end
it 'dissalows :public_projects_minutes_cost_factor being negative' do
runner = build(:ci_runner, public_projects_minutes_cost_factor: -2.2)
expect(runner).to be_invalid
expect(runner.errors.full_messages).to include('Public projects minutes cost factor needs to be non-negative')
end
end
2016-06-02 11:05:42 +05:30
end
2019-12-04 20:38:33 +05:30
describe 'constraints' do
it '.UPDATE_CONTACT_COLUMN_EVERY' do
expect(described_class::UPDATE_CONTACT_COLUMN_EVERY.max)
.to be <= described_class::ONLINE_CONTACT_TIMEOUT
end
end
2018-03-17 18:26:18 +05:30
describe '#access_level' do
context 'when creating new runner and access_level is nil' do
let(:runner) do
build(:ci_runner, access_level: nil)
end
it "object is invalid" do
expect(runner).not_to be_valid
end
end
context 'when creating new runner and access_level is defined in enum' do
let(:runner) do
build(:ci_runner, access_level: :not_protected)
end
it "object is valid" do
expect(runner).to be_valid
end
end
context 'when creating new runner and access_level is not defined in enum' do
it "raises an error" do
expect { build(:ci_runner, access_level: :this_is_not_defined) }.to raise_error(ArgumentError)
end
end
end
2018-11-08 19:23:39 +05:30
describe '.instance_type' do
2018-10-15 14:42:47 +05:30
let(:group) { create(:group) }
let(:project) { create(:project) }
2018-11-08 19:23:39 +05:30
let!(:group_runner) { create(:ci_runner, :group, groups: [group]) }
let!(:project_runner) { create(:ci_runner, :project, projects: [project]) }
let!(:shared_runner) { create(:ci_runner, :instance) }
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
it 'returns only shared runners' do
expect(described_class.instance_type).to contain_exactly(shared_runner)
2018-10-15 14:42:47 +05:30
end
end
describe '.belonging_to_project' do
it 'returns the specific project runner' do
# own
specific_project = create(:project)
2018-11-08 19:23:39 +05:30
specific_runner = create(:ci_runner, :project, projects: [specific_project])
2018-10-15 14:42:47 +05:30
# other
other_project = create(:project)
2018-11-08 19:23:39 +05:30
create(:ci_runner, :project, projects: [other_project])
2018-10-15 14:42:47 +05:30
expect(described_class.belonging_to_project(specific_project.id)).to eq [specific_runner]
end
end
describe '.belonging_to_parent_group_of_project' do
let(:project) { create(:project, group: group) }
let(:group) { create(:group) }
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :group, groups: [group]) }
2018-10-15 14:42:47 +05:30
let!(:unrelated_group) { create(:group) }
let!(:unrelated_project) { create(:project, group: unrelated_group) }
2018-11-08 19:23:39 +05:30
let!(:unrelated_runner) { create(:ci_runner, :group, groups: [unrelated_group]) }
2018-10-15 14:42:47 +05:30
it 'returns the specific group runner' do
expect(described_class.belonging_to_parent_group_of_project(project.id)).to contain_exactly(runner)
end
2019-10-12 21:52:04 +05:30
context 'with a parent group with a runner' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :group, groups: [parent_group]) }
2018-10-15 14:42:47 +05:30
let(:project) { create(:project, group: group) }
let(:group) { create(:group, parent: parent_group) }
let(:parent_group) { create(:group) }
it 'returns the group runner from the parent group' do
expect(described_class.belonging_to_parent_group_of_project(project.id)).to contain_exactly(runner)
end
end
end
2018-11-08 19:23:39 +05:30
describe '.owned_or_instance_wide' do
2018-10-15 14:42:47 +05:30
it 'returns a globally shared, a project specific and a group specific runner' do
# group specific
group = create(:group)
project = create(:project, group: group)
2018-11-08 19:23:39 +05:30
group_runner = create(:ci_runner, :group, groups: [group])
2018-10-15 14:42:47 +05:30
# project specific
2018-11-08 19:23:39 +05:30
project_runner = create(:ci_runner, :project, projects: [project])
2018-10-15 14:42:47 +05:30
# globally shared
2018-11-08 19:23:39 +05:30
shared_runner = create(:ci_runner, :instance)
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
expect(described_class.owned_or_instance_wide(project.id)).to contain_exactly(
2018-10-15 14:42:47 +05:30
group_runner, project_runner, shared_runner
)
end
end
2015-09-25 12:07:36 +05:30
describe '#display_name' do
2016-06-22 15:30:34 +05:30
it 'returns the description if it has a value' do
2018-11-08 19:23:39 +05:30
runner = build(:ci_runner, description: 'Linux/Ruby-1.9.3-p448')
2015-09-25 12:07:36 +05:30
expect(runner.display_name).to eq 'Linux/Ruby-1.9.3-p448'
end
2016-06-22 15:30:34 +05:30
it 'returns the token if it does not have a description' do
2018-11-08 19:23:39 +05:30
runner = create(:ci_runner)
2015-09-25 12:07:36 +05:30
expect(runner.display_name).to eq runner.description
end
2016-06-22 15:30:34 +05:30
it 'returns the token if the description is an empty string' do
2018-11-08 19:23:39 +05:30
runner = build(:ci_runner, description: '', token: 'token')
2015-09-25 12:07:36 +05:30
expect(runner.display_name).to eq runner.token
end
end
2016-06-22 15:30:34 +05:30
describe '#assign_to' do
2018-11-08 19:23:39 +05:30
let(:project) { create(:project) }
2015-09-25 12:07:36 +05:30
2018-10-15 14:42:47 +05:30
subject { runner.assign_to(project) }
2018-11-08 19:23:39 +05:30
context 'with shared_runner' do
let(:runner) { create(:ci_runner, :instance) }
2018-10-15 14:42:47 +05:30
it 'transitions shared runner to project runner and assigns project' do
2018-11-08 19:23:39 +05:30
expect(subject).to be_truthy
2018-10-15 14:42:47 +05:30
expect(runner).to be_project_type
expect(runner.projects).to eq([project])
expect(runner.only_for?(project)).to be_truthy
end
2016-06-22 15:30:34 +05:30
end
2015-09-25 12:07:36 +05:30
2018-10-15 14:42:47 +05:30
context 'with group runner' do
2018-11-08 19:23:39 +05:30
let(:group) { create(:group) }
let(:runner) { create(:ci_runner, :group, groups: [group]) }
2018-10-15 14:42:47 +05:30
it 'raises an error' do
expect { subject }
.to raise_error(ArgumentError, 'Transitioning a group runner to a project runner is not supported')
end
end
2015-09-25 12:07:36 +05:30
end
2016-06-22 15:30:34 +05:30
describe '.online' do
2017-09-10 17:25:29 +05:30
subject { described_class.online }
2015-10-24 18:46:33 +05:30
before do
2020-06-23 00:09:42 +05:30
@runner1 = create(:ci_runner, :instance, contacted_at: 2.hours.ago)
2018-11-08 19:23:39 +05:30
@runner2 = create(:ci_runner, :instance, contacted_at: 1.second.ago)
2015-10-24 18:46:33 +05:30
end
it { is_expected.to eq([@runner2])}
end
2020-05-24 23:13:21 +05:30
describe '#online?', :clean_gitlab_redis_cache do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :instance) }
2015-10-24 18:46:33 +05:30
subject { runner.online? }
2018-03-17 18:26:18 +05:30
before do
allow_any_instance_of(described_class).to receive(:cached_attribute).and_call_original
allow_any_instance_of(described_class).to receive(:cached_attribute)
.with(:platform).and_return("darwin")
end
context 'no cache value' do
2016-06-22 15:30:34 +05:30
before do
2018-03-17 18:26:18 +05:30
stub_redis_runner_contacted_at(nil)
2016-06-22 15:30:34 +05:30
end
2015-10-24 18:46:33 +05:30
2018-03-17 18:26:18 +05:30
context 'never contacted' do
before do
runner.contacted_at = nil
end
2015-10-24 18:46:33 +05:30
2018-03-17 18:26:18 +05:30
it { is_expected.to be_falsey }
2016-06-22 15:30:34 +05:30
end
2015-10-24 18:46:33 +05:30
2018-03-17 18:26:18 +05:30
context 'contacted long time ago time' do
before do
runner.contacted_at = 1.year.ago
end
it { is_expected.to be_falsey }
end
context 'contacted 1s ago' do
before do
runner.contacted_at = 1.second.ago
end
it { is_expected.to be_truthy }
end
2015-10-24 18:46:33 +05:30
end
2018-03-17 18:26:18 +05:30
context 'with cache value' do
context 'contacted long time ago time' do
before do
runner.contacted_at = 1.year.ago
stub_redis_runner_contacted_at(1.year.ago.to_s)
end
it { is_expected.to be_falsey }
2016-06-22 15:30:34 +05:30
end
2015-10-24 18:46:33 +05:30
2018-03-17 18:26:18 +05:30
context 'contacted 1s ago' do
before do
runner.contacted_at = 50.minutes.ago
stub_redis_runner_contacted_at(1.second.ago.to_s)
end
it { is_expected.to be_truthy }
end
end
def stub_redis_runner_contacted_at(value)
2020-05-24 23:13:21 +05:30
Gitlab::Redis::Cache.with do |redis|
2018-03-17 18:26:18 +05:30
cache_key = runner.send(:cache_attribute_key)
expect(redis).to receive(:get).with(cache_key)
.and_return({ contacted_at: value }.to_json).at_least(:once)
end
2015-10-24 18:46:33 +05:30
end
end
2018-12-05 23:21:45 +05:30
describe '.offline' do
subject { described_class.offline }
before do
2020-06-23 00:09:42 +05:30
@runner1 = create(:ci_runner, :instance, contacted_at: 2.hours.ago)
2018-12-05 23:21:45 +05:30
@runner2 = create(:ci_runner, :instance, contacted_at: 1.second.ago)
end
it { is_expected.to eq([@runner1])}
end
2016-06-22 15:30:34 +05:30
describe '#can_pick?' do
2020-03-13 15:44:24 +05:30
let_it_be(:pipeline) { create(:ci_pipeline) }
2016-06-22 15:30:34 +05:30
let(:build) { create(:ci_build, pipeline: pipeline) }
2018-11-08 19:23:39 +05:30
let(:runner_project) { build.project }
let(:runner) { create(:ci_runner, :project, projects: [runner_project], tag_list: tag_list, run_untagged: run_untagged) }
2018-10-15 14:42:47 +05:30
let(:tag_list) { [] }
let(:run_untagged) { true }
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
subject { runner.can_pick?(build) }
2018-10-15 14:42:47 +05:30
context 'a different runner' do
2018-11-08 19:23:39 +05:30
let(:other_project) { create(:project) }
let(:other_runner) { create(:ci_runner, :project, projects: [other_project], tag_list: tag_list, run_untagged: run_untagged) }
2018-10-15 14:42:47 +05:30
it 'cannot handle builds' do
expect(other_runner.can_pick?(build)).to be_falsey
end
end
2016-06-22 15:30:34 +05:30
context 'when runner does not have tags' do
it 'can handle builds without tags' do
expect(runner.can_pick?(build)).to be_truthy
end
it 'cannot handle build with tags' do
build.tag_list = ['aa']
expect(runner.can_pick?(build)).to be_falsey
end
end
context 'when runner has tags' do
2018-10-15 14:42:47 +05:30
let(:tag_list) { %w(bb cc) }
2016-06-22 15:30:34 +05:30
shared_examples 'tagged build picker' do
it 'can handle build with matching tags' do
build.tag_list = ['bb']
expect(runner.can_pick?(build)).to be_truthy
end
it 'cannot handle build without matching tags' do
build.tag_list = ['aa']
expect(runner.can_pick?(build)).to be_falsey
end
end
context 'when runner can pick untagged jobs' do
it 'can handle builds without tags' do
expect(runner.can_pick?(build)).to be_truthy
end
it_behaves_like 'tagged build picker'
end
context 'when runner cannot pick untagged jobs' do
2018-10-15 14:42:47 +05:30
let(:run_untagged) { false }
2016-06-22 15:30:34 +05:30
it 'cannot handle builds without tags' do
expect(runner.can_pick?(build)).to be_falsey
end
it_behaves_like 'tagged build picker'
end
end
2018-03-17 18:26:18 +05:30
context 'when runner is shared' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :instance) }
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
it 'can handle builds' do
expect(runner.can_pick?(build)).to be_truthy
end
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
context 'when runner is locked' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :instance, locked: true) }
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
it 'can handle builds' do
expect(runner.can_pick?(build)).to be_truthy
2016-06-22 15:30:34 +05:30
end
end
2018-03-17 18:26:18 +05:30
end
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
context 'when runner is not shared' do
context 'when runner is assigned to a project' do
it 'can handle builds' do
2016-06-22 15:30:34 +05:30
expect(runner.can_pick?(build)).to be_truthy
end
2018-03-17 18:26:18 +05:30
end
2016-06-22 15:30:34 +05:30
2018-11-08 19:23:39 +05:30
context 'when runner is assigned to another project' do
let(:runner_project) { create(:project) }
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
it 'cannot handle builds' do
expect(runner.can_pick?(build)).to be_falsey
2016-06-22 15:30:34 +05:30
end
end
2018-10-15 14:42:47 +05:30
context 'when runner is assigned to a group' do
2018-11-08 19:23:39 +05:30
let(:group) { create(:group, projects: [build.project]) }
let(:runner) { create(:ci_runner, :group, tag_list: tag_list, run_untagged: run_untagged, groups: [group]) }
2018-10-15 14:42:47 +05:30
it 'can handle builds' do
expect(runner.can_pick?(build)).to be_truthy
end
end
2018-03-17 18:26:18 +05:30
end
context 'when access_level of runner is not_protected' do
before do
runner.not_protected!
end
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
context 'when build is protected' do
2016-06-22 15:30:34 +05:30
before do
2018-03-17 18:26:18 +05:30
build.protected = true
2016-06-22 15:30:34 +05:30
end
2018-03-17 18:26:18 +05:30
it { is_expected.to be_truthy }
end
context 'when build is unprotected' do
before do
build.protected = false
2016-06-22 15:30:34 +05:30
end
2018-03-17 18:26:18 +05:30
it { is_expected.to be_truthy }
end
end
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
context 'when access_level of runner is ref_protected' do
before do
runner.ref_protected!
end
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
context 'when build is protected' do
before do
build.protected = true
2016-06-22 15:30:34 +05:30
end
2018-03-17 18:26:18 +05:30
it { is_expected.to be_truthy }
end
context 'when build is unprotected' do
before do
build.protected = false
end
it { is_expected.to be_falsey }
2016-06-22 15:30:34 +05:30
end
end
end
describe '#status' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :instance, contacted_at: 1.second.ago) }
2015-10-24 18:46:33 +05:30
subject { runner.status }
context 'never connected' do
2016-06-22 15:30:34 +05:30
before do
runner.contacted_at = nil
end
2015-10-24 18:46:33 +05:30
it { is_expected.to eq(:not_connected) }
end
context 'contacted 1s ago' do
2016-06-22 15:30:34 +05:30
before do
runner.contacted_at = 1.second.ago
end
2015-10-24 18:46:33 +05:30
it { is_expected.to eq(:online) }
end
context 'contacted long time ago' do
2016-06-22 15:30:34 +05:30
before do
runner.contacted_at = 1.year.ago
end
2015-10-24 18:46:33 +05:30
it { is_expected.to eq(:offline) }
end
context 'inactive' do
2016-06-22 15:30:34 +05:30
before do
runner.active = false
end
2015-10-24 18:46:33 +05:30
it { is_expected.to eq(:paused) }
end
end
2017-08-17 22:00:37 +05:30
describe '#tick_runner_queue' do
let(:runner) { create(:ci_runner) }
it 'returns a new last_update value' do
expect(runner.tick_runner_queue).not_to be_empty
end
end
describe '#ensure_runner_queue_value' do
let(:runner) { create(:ci_runner) }
it 'sets a new last_update value when it is called the first time' do
last_update = runner.ensure_runner_queue_value
2020-04-22 19:07:51 +05:30
expect(value_in_queues).to eq(last_update)
2017-08-17 22:00:37 +05:30
end
it 'does not change if it is not expired and called again' do
last_update = runner.ensure_runner_queue_value
expect(runner.ensure_runner_queue_value).to eq(last_update)
2020-04-22 19:07:51 +05:30
expect(value_in_queues).to eq(last_update)
2017-08-17 22:00:37 +05:30
end
context 'updates runner queue after changing editable value' do
let!(:last_update) { runner.ensure_runner_queue_value }
before do
Ci::UpdateRunnerService.new(runner).update(description: 'new runner')
end
it 'sets a new last_update value' do
2020-04-22 19:07:51 +05:30
expect(value_in_queues).not_to eq(last_update)
2017-08-17 22:00:37 +05:30
end
end
context 'does not update runner value after save' do
let!(:last_update) { runner.ensure_runner_queue_value }
before do
runner.touch
end
it 'has an old last_update value' do
2020-04-22 19:07:51 +05:30
expect(value_in_queues).to eq(last_update)
2017-08-17 22:00:37 +05:30
end
end
2020-04-22 19:07:51 +05:30
def value_in_queues
2019-10-12 21:52:04 +05:30
Gitlab::Redis::SharedState.with do |redis|
2017-08-17 22:00:37 +05:30
runner_queue_key = runner.send(:runner_queue_key)
2020-04-22 19:07:51 +05:30
redis.get(runner_queue_key)
2017-08-17 22:00:37 +05:30
end
end
end
2020-06-23 00:09:42 +05:30
describe '#heartbeat' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :project) }
2018-03-17 18:26:18 +05:30
2020-06-23 00:09:42 +05:30
subject { runner.heartbeat(architecture: '18-bit') }
2018-03-17 18:26:18 +05:30
context 'when database was updated recently' do
before do
2020-06-23 00:09:42 +05:30
runner.contacted_at = Time.current
2018-03-17 18:26:18 +05:30
end
it 'updates cache' do
expect_redis_update
subject
end
end
context 'when database was not updated recently' do
before do
runner.contacted_at = 2.hours.ago
end
2018-11-08 19:23:39 +05:30
context 'with invalid runner' do
before do
runner.projects = []
end
it 'still updates redis cache and database' do
expect(runner).to be_invalid
2018-03-17 18:26:18 +05:30
2018-11-08 19:23:39 +05:30
expect_redis_update
does_db_update
end
2018-03-17 18:26:18 +05:30
end
2018-11-08 19:23:39 +05:30
it 'updates redis cache and database' do
2018-03-17 18:26:18 +05:30
expect_redis_update
2018-11-08 19:23:39 +05:30
does_db_update
2018-03-17 18:26:18 +05:30
end
end
def expect_redis_update
2020-05-24 23:13:21 +05:30
Gitlab::Redis::Cache.with do |redis|
2018-03-17 18:26:18 +05:30
redis_key = runner.send(:cache_attribute_key)
expect(redis).to receive(:set).with(redis_key, anything, any_args)
end
end
2018-11-08 19:23:39 +05:30
def does_db_update
expect { subject }.to change { runner.reload.read_attribute(:contacted_at) }
.and change { runner.reload.read_attribute(:architecture) }
end
2018-03-17 18:26:18 +05:30
end
2017-08-17 22:00:37 +05:30
describe '#destroy' do
let(:runner) { create(:ci_runner) }
context 'when there is a tick in the queue' do
let!(:queue_key) { runner.send(:runner_queue_key) }
before do
runner.tick_runner_queue
runner.destroy
end
it 'cleans up the queue' do
2020-05-24 23:13:21 +05:30
Gitlab::Redis::Cache.with do |redis|
2017-08-17 22:00:37 +05:30
expect(redis.get(queue_key)).to be_nil
end
end
end
end
2016-06-22 15:30:34 +05:30
describe '.assignable_for' do
2017-09-10 17:25:29 +05:30
let(:project) { create(:project) }
2018-11-08 19:23:39 +05:30
let(:group) { create(:group) }
2017-09-10 17:25:29 +05:30
let(:another_project) { create(:project) }
2018-11-08 19:23:39 +05:30
let!(:unlocked_project_runner) { create(:ci_runner, :project, projects: [project]) }
let!(:locked_project_runner) { create(:ci_runner, :project, locked: true, projects: [project]) }
let!(:group_runner) { create(:ci_runner, :group, groups: [group]) }
let!(:instance_runner) { create(:ci_runner, :instance) }
2016-06-22 15:30:34 +05:30
2018-11-08 19:23:39 +05:30
context 'with already assigned project' do
subject { described_class.assignable_for(project) }
2016-06-22 15:30:34 +05:30
2018-11-08 19:23:39 +05:30
it { is_expected.to be_empty }
2016-06-22 15:30:34 +05:30
end
2018-11-08 19:23:39 +05:30
context 'with a different project' do
subject { described_class.assignable_for(another_project) }
2016-06-22 15:30:34 +05:30
2018-11-08 19:23:39 +05:30
it { is_expected.to include(unlocked_project_runner) }
it { is_expected.not_to include(group_runner) }
it { is_expected.not_to include(locked_project_runner) }
it { is_expected.not_to include(instance_runner) }
2016-06-22 15:30:34 +05:30
end
end
2015-09-25 12:07:36 +05:30
describe "belongs_to_one_project?" do
it "returns false if there are two projects runner assigned to" do
2018-11-08 19:23:39 +05:30
project1 = create(:project)
project2 = create(:project)
runner = create(:ci_runner, :project, projects: [project1, project2])
2015-09-25 12:07:36 +05:30
expect(runner.belongs_to_one_project?).to be_falsey
end
it "returns true" do
2018-11-08 19:23:39 +05:30
project = create(:project)
runner = create(:ci_runner, :project, projects: [project])
2015-09-25 12:07:36 +05:30
expect(runner.belongs_to_one_project?).to be_truthy
end
end
2016-06-02 11:05:42 +05:30
2020-07-28 23:09:34 +05:30
describe '#belongs_to_more_than_one_project?' do
context 'project runner' do
let(:project1) { create(:project) }
let(:project2) { create(:project) }
context 'two projects assigned to runner' do
let(:runner) { create(:ci_runner, :project, projects: [project1, project2]) }
it 'returns true' do
expect(runner.belongs_to_more_than_one_project?).to be_truthy
end
end
context 'one project assigned to runner' do
let(:runner) { create(:ci_runner, :project, projects: [project1]) }
it 'returns false' do
expect(runner.belongs_to_more_than_one_project?).to be_falsey
end
end
end
context 'group runner' do
let(:group) { create(:group) }
let(:runner) { create(:ci_runner, :group, groups: [group]) }
it 'returns false' do
expect(runner.belongs_to_more_than_one_project?).to be_falsey
end
end
context 'shared runner' do
let(:runner) { create(:ci_runner, :instance) }
it 'returns false' do
expect(runner.belongs_to_more_than_one_project?).to be_falsey
end
end
end
2016-06-02 11:05:42 +05:30
describe '#has_tags?' do
context 'when runner has tags' do
subject { create(:ci_runner, tag_list: ['tag']) }
2019-12-21 20:55:43 +05:30
2016-06-02 11:05:42 +05:30
it { is_expected.to have_tags }
end
context 'when runner does not have tags' do
subject { create(:ci_runner, tag_list: []) }
2019-12-21 20:55:43 +05:30
it { is_expected.not_to have_tags }
2016-06-02 11:05:42 +05:30
end
end
describe '.search' do
2018-03-17 18:26:18 +05:30
let(:runner) { create(:ci_runner, token: '123abc', description: 'test runner') }
2016-06-02 11:05:42 +05:30
it 'returns runners with a matching token' do
expect(described_class.search(runner.token)).to eq([runner])
end
it 'returns runners with a partially matching token' do
expect(described_class.search(runner.token[0..2])).to eq([runner])
end
it 'returns runners with a matching token regardless of the casing' do
expect(described_class.search(runner.token.upcase)).to eq([runner])
end
it 'returns runners with a matching description' do
expect(described_class.search(runner.description)).to eq([runner])
end
it 'returns runners with a partially matching description' do
expect(described_class.search(runner.description[0..2])).to eq([runner])
end
it 'returns runners with a matching description regardless of the casing' do
expect(described_class.search(runner.description.upcase)).to eq([runner])
end
end
2018-10-15 14:42:47 +05:30
describe '#assigned_to_group?' do
subject { runner.assigned_to_group? }
context 'when project runner' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :project, description: 'Project runner', projects: [project]) }
2018-10-15 14:42:47 +05:30
let(:project) { create(:project) }
it { is_expected.to be_falsey }
end
context 'when shared runner' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :instance, description: 'Shared runner') }
2018-10-15 14:42:47 +05:30
it { is_expected.to be_falsey }
end
context 'when group runner' do
let(:group) { create(:group) }
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :group, description: 'Group runner', groups: [group]) }
2018-10-15 14:42:47 +05:30
it { is_expected.to be_truthy }
end
end
describe '#assigned_to_project?' do
subject { runner.assigned_to_project? }
context 'when group runner' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :group, description: 'Group runner', groups: [group]) }
2018-10-15 14:42:47 +05:30
let(:group) { create(:group) }
2020-03-13 15:44:24 +05:30
2018-10-15 14:42:47 +05:30
it { is_expected.to be_falsey }
end
context 'when shared runner' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :instance, description: 'Shared runner') }
2020-03-13 15:44:24 +05:30
2018-10-15 14:42:47 +05:30
it { is_expected.to be_falsey }
end
context 'when project runner' do
2018-11-08 19:23:39 +05:30
let(:runner) { create(:ci_runner, :project, description: 'Project runner', projects: [project]) }
2018-10-15 14:42:47 +05:30
let(:project) { create(:project) }
it { is_expected.to be_truthy }
end
end
describe '#pick_build!' do
context 'runner can pick the build' do
it 'calls #tick_runner_queue' do
ci_build = build(:ci_build)
runner = build(:ci_runner)
allow(runner).to receive(:can_pick?).with(ci_build).and_return(true)
expect(runner).to receive(:tick_runner_queue)
runner.pick_build!(ci_build)
end
end
context 'runner cannot pick the build' do
it 'does not call #tick_runner_queue' do
ci_build = build(:ci_build)
runner = build(:ci_runner)
allow(runner).to receive(:can_pick?).with(ci_build).and_return(false)
expect(runner).not_to receive(:tick_runner_queue)
runner.pick_build!(ci_build)
end
end
end
2018-11-08 19:23:39 +05:30
describe 'project runner without projects is destroyable' do
subject { create(:ci_runner, :project, :without_projects) }
it 'does not have projects' do
expect(subject.runner_projects).to be_empty
end
it 'can be destroyed' do
subject
expect { subject.destroy }.to change { described_class.count }.by(-1)
end
end
2018-12-05 23:21:45 +05:30
describe '.order_by' do
it 'supports ordering by the contact date' do
runner1 = create(:ci_runner, contacted_at: 1.year.ago)
runner2 = create(:ci_runner, contacted_at: 1.month.ago)
runners = described_class.order_by('contacted_asc')
expect(runners).to eq([runner1, runner2])
end
it 'supports ordering by the creation date' do
runner1 = create(:ci_runner, created_at: 1.year.ago)
runner2 = create(:ci_runner, created_at: 1.month.ago)
runners = described_class.order_by('created_asc')
expect(runners).to eq([runner2, runner1])
end
end
2019-02-15 15:39:39 +05:30
describe '#uncached_contacted_at' do
let(:contacted_at_stored) { 1.hour.ago.change(usec: 0) }
let(:runner) { create(:ci_runner, contacted_at: contacted_at_stored) }
subject { runner.uncached_contacted_at }
it { is_expected.to eq(contacted_at_stored) }
end
2020-04-22 19:07:51 +05:30
describe '.belonging_to_group' do
it 'returns the specific group runner' do
group = create(:group)
runner = create(:ci_runner, :group, groups: [group])
unrelated_group = create(:group)
create(:ci_runner, :group, groups: [unrelated_group])
expect(described_class.belonging_to_group(group.id)).to contain_exactly(runner)
end
context 'runner belonging to parent group' do
let_it_be(:parent_group) { create(:group) }
let_it_be(:parent_runner) { create(:ci_runner, :group, groups: [parent_group]) }
let_it_be(:group) { create(:group, parent: parent_group) }
context 'when include_parent option is passed' do
it 'returns the group runner from the parent group' do
expect(described_class.belonging_to_group(group.id, include_ancestors: true)).to contain_exactly(parent_runner)
end
end
context 'when include_parent option is not passed' do
it 'does not return the group runner from the parent group' do
expect(described_class.belonging_to_group(group.id)).to be_empty
end
end
end
end
2015-09-25 12:07:36 +05:30
end