debian-mirror-gitlab/spec/controllers/projects/jobs_controller_spec.rb

1219 lines
38 KiB
Ruby
Raw Normal View History

2019-07-31 22:56:46 +05:30
# frozen_string_literal: true
2017-08-17 22:00:37 +05:30
require 'spec_helper'
2018-10-15 14:42:47 +05:30
describe Projects::JobsController, :clean_gitlab_redis_shared_state do
2017-08-17 22:00:37 +05:30
include ApiHelpers
2018-05-09 12:01:36 +05:30
include HttpIOHelpers
2017-08-17 22:00:37 +05:30
2020-01-01 13:55:28 +05:30
let(:project) { create(:project, :public, :repository) }
2017-08-17 22:00:37 +05:30
let(:pipeline) { create(:ci_pipeline, project: project) }
let(:user) { create(:user) }
2017-09-10 17:25:29 +05:30
before do
2018-10-15 14:42:47 +05:30
stub_feature_flags(ci_enable_live_trace: true)
2017-09-10 17:25:29 +05:30
stub_not_protect_default_branch
end
2017-08-17 22:00:37 +05:30
describe 'GET index' do
context 'when scope is pending' do
before do
create(:ci_build, :pending, pipeline: pipeline)
get_index(scope: 'pending')
end
it 'has only pending builds' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-08-17 22:00:37 +05:30
expect(assigns(:builds).first.status).to eq('pending')
end
end
context 'when scope is running' do
before do
create(:ci_build, :running, pipeline: pipeline)
get_index(scope: 'running')
end
2017-09-10 17:25:29 +05:30
it 'has only running jobs' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-08-17 22:00:37 +05:30
expect(assigns(:builds).first.status).to eq('running')
end
end
context 'when scope is finished' do
before do
create(:ci_build, :success, pipeline: pipeline)
get_index(scope: 'finished')
end
2017-09-10 17:25:29 +05:30
it 'has only finished jobs' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-08-17 22:00:37 +05:30
expect(assigns(:builds).first.status).to eq('success')
end
end
context 'when page is specified' do
let(:last_page) { project.builds.page.total_pages }
context 'when page number is eligible' do
before do
create_list(:ci_build, 2, pipeline: pipeline)
get_index(page: last_page.to_param)
end
it 'redirects to the page' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-08-17 22:00:37 +05:30
expect(assigns(:builds).current_page).to eq(last_page)
end
end
end
context 'number of queries' do
2019-09-30 21:07:59 +05:30
render_views
2017-08-17 22:00:37 +05:30
before do
Ci::Build::AVAILABLE_STATUSES.each do |status|
2017-09-10 17:25:29 +05:30
create_job(status, status)
2017-08-17 22:00:37 +05:30
end
2019-09-30 21:07:59 +05:30
allow(Appearance).to receive(:current_without_cache)
.and_return(nil)
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
it 'verifies number of queries', :request_store do
2019-09-30 21:07:59 +05:30
expect { get_index }.not_to be_n_plus_1_query.with_threshold(3)
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
def create_job(name, status)
2019-09-30 21:07:59 +05:30
user = create(:user)
pipeline = create(:ci_pipeline, project: project, user: user)
2017-08-17 22:00:37 +05:30
create(:ci_build, :tags, :triggered, :artifacts,
2019-09-30 21:07:59 +05:30
pipeline: pipeline, name: name, status: status,
user: user)
2017-08-17 22:00:37 +05:30
end
end
def get_index(**extra_params)
params = {
namespace_id: project.namespace.to_param,
project_id: project
}
2019-02-15 15:39:39 +05:30
get :index, params: params.merge(extra_params)
2017-08-17 22:00:37 +05:30
end
end
2019-09-04 21:01:54 +05:30
describe 'GET show', :request_store do
2017-09-10 17:25:29 +05:30
let!(:job) { create(:ci_build, :failed, pipeline: pipeline) }
2018-11-08 19:23:39 +05:30
let!(:second_job) { create(:ci_build, :failed, pipeline: pipeline) }
let!(:third_job) { create(:ci_build, :failed) }
2017-08-17 22:00:37 +05:30
2017-09-10 17:25:29 +05:30
context 'when requesting HTML' do
context 'when job exists' do
before do
get_show(id: job.id)
end
it 'has a job' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-09-10 17:25:29 +05:30
expect(assigns(:build).id).to eq(job.id)
end
2018-11-08 19:23:39 +05:30
it 'has the correct build collection' do
builds = assigns(:builds).map(&:id)
expect(builds).to include(job.id, second_job.id)
expect(builds).not_to include(third_job.id)
end
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
context 'when job does not exist' do
before do
get_show(id: 1234)
end
it 'renders not_found' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2017-09-10 17:25:29 +05:30
end
2017-08-17 22:00:37 +05:30
end
end
2017-09-10 17:25:29 +05:30
context 'when requesting JSON' do
let(:merge_request) { create(:merge_request, source_project: project) }
2017-08-17 22:00:37 +05:30
before do
2017-09-10 17:25:29 +05:30
project.add_developer(user)
sign_in(user)
2019-09-04 21:01:54 +05:30
allow_any_instance_of(Ci::Build)
.to receive(:merge_request)
.and_return(merge_request)
end
2020-01-01 13:55:28 +05:30
it 'does not serialize builds in exposed stages' do
2019-09-04 21:01:54 +05:30
get_show_json
2017-09-10 17:25:29 +05:30
2019-09-04 21:01:54 +05:30
json_response.dig('pipeline', 'details', 'stages').tap do |stages|
2019-10-12 21:52:04 +05:30
expect(stages.flat_map(&:keys))
2019-09-04 21:01:54 +05:30
.to eq %w[name title status path dropdown_path]
end
2017-08-17 22:00:37 +05:30
end
2018-11-20 20:47:30 +05:30
context 'when job failed' do
it 'exposes needed information' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-11-20 20:47:30 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['raw_path']).to match(%r{jobs/\d+/raw\z})
2018-12-13 13:39:08 +05:30
expect(json_response['merge_request']['path']).to match(%r{merge_requests/\d+\z})
2018-11-20 20:47:30 +05:30
expect(json_response['new_issue_path']).to include('/issues/new')
end
end
2018-12-13 13:39:08 +05:30
context 'when job is running' do
2019-09-04 21:01:54 +05:30
before do
get_show_json
end
2018-12-13 13:39:08 +05:30
context 'job is cancelable' do
let(:job) { create(:ci_build, :running, pipeline: pipeline) }
2020-01-01 13:55:28 +05:30
it 'cancel_path is present with correct redirect' do
2018-12-13 13:39:08 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['cancel_path']).to include(CGI.escape(json_response['build_path']))
end
end
context 'with web terminal' do
let(:job) { create(:ci_build, :running, :with_runner_session, pipeline: pipeline) }
2020-01-01 13:55:28 +05:30
it 'exposes the terminal path' do
2018-12-13 13:39:08 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['terminal_path']).to match(%r{/terminal})
end
end
end
2018-11-20 20:47:30 +05:30
context 'when job has artifacts' do
2019-09-04 21:01:54 +05:30
before do
get_show_json
end
2018-11-20 20:47:30 +05:30
context 'with not expiry date' do
let(:job) { create(:ci_build, :success, :artifacts, pipeline: pipeline) }
it 'exposes needed information' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['artifact']['download_path']).to match(%r{artifacts/download})
expect(json_response['artifact']['browse_path']).to match(%r{artifacts/browse})
expect(json_response['artifact']).not_to have_key('expired')
expect(json_response['artifact']).not_to have_key('expired_at')
end
end
context 'with expiry date' do
let(:job) { create(:ci_build, :success, :artifacts, :expired, pipeline: pipeline) }
it 'exposes needed information' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['artifact']).not_to have_key('download_path')
expect(json_response['artifact']).not_to have_key('browse_path')
expect(json_response['artifact']['expired']).to eq(true)
expect(json_response['artifact']['expire_at']).not_to be_empty
end
end
end
2018-12-05 23:21:45 +05:30
context 'when job passed with no trace' do
let(:job) { create(:ci_build, :success, :artifacts, pipeline: pipeline) }
it 'exposes empty state illustrations' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['status']['illustration']).to have_key('image')
expect(json_response['status']['illustration']).to have_key('size')
expect(json_response['status']['illustration']).to have_key('title')
end
end
context 'with no deployment' do
let(:job) { create(:ci_build, :success, pipeline: pipeline) }
it 'does not exposes the deployment information' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response['deployment_status']).to be_nil
end
end
context 'with deployment' do
let(:merge_request) { create(:merge_request, source_project: project) }
let(:environment) { create(:environment, project: project, name: 'staging', state: :available) }
2018-12-13 13:39:08 +05:30
let(:job) { create(:ci_build, :running, environment: environment.name, pipeline: pipeline) }
2018-12-05 23:21:45 +05:30
2019-09-04 21:01:54 +05:30
before do
2019-12-04 20:38:33 +05:30
create(:deployment, :success, :on_cluster, environment: environment, project: project)
project.add_maintainer(user) # Need to be a maintianer to view cluster.path
2019-09-04 21:01:54 +05:30
end
2020-01-01 13:55:28 +05:30
it 'exposes the deployment information' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response).to match_schema('job/job_details')
2019-09-04 21:01:54 +05:30
expect(json_response.dig('deployment_status', 'status')).to eq 'creating'
expect(json_response.dig('deployment_status', 'environment')).not_to be_nil
expect(json_response.dig('deployment_status', 'environment', 'last_deployment')).not_to be_nil
2019-12-04 20:38:33 +05:30
expect(json_response.dig('deployment_status', 'environment', 'last_deployment')).not_to include('commit')
expect(json_response.dig('deployment_status', 'environment', 'last_deployment', 'cluster', 'name')).to eq('test-cluster')
expect(json_response.dig('deployment_status', 'environment', 'last_deployment', 'cluster', 'path')).to be_present
2018-12-05 23:21:45 +05:30
end
end
context 'when user can edit runner' do
context 'that belongs to the project' do
let(:runner) { create(:ci_runner, :project, projects: [project]) }
let(:job) { create(:ci_build, :success, pipeline: pipeline, runner: runner) }
before do
project.add_maintainer(user)
sign_in(user)
end
2020-01-01 13:55:28 +05:30
it 'user can edit runner' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['runner']).to have_key('edit_path')
end
end
context 'that belongs to group' do
let(:group) { create(:group) }
let(:runner) { create(:ci_runner, :group, groups: [group]) }
let(:job) { create(:ci_build, :success, pipeline: pipeline, runner: runner) }
let(:user) { create(:user, :admin) }
before do
project.add_maintainer(user)
sign_in(user)
end
2020-01-01 13:55:28 +05:30
it 'user can not edit runner' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['runner']).not_to have_key('edit_path')
end
end
context 'that belongs to instance' do
let(:runner) { create(:ci_runner, :instance) }
let(:job) { create(:ci_build, :success, pipeline: pipeline, runner: runner) }
let(:user) { create(:user, :admin) }
before do
project.add_maintainer(user)
sign_in(user)
end
2020-01-01 13:55:28 +05:30
it 'user can not edit runner' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['runner']).not_to have_key('edit_path')
end
end
end
context 'when no runners are available' do
let(:runner) { create(:ci_runner, :instance, active: false) }
let(:job) { create(:ci_build, :pending, pipeline: pipeline, runner: runner) }
it 'exposes needed information' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['runners']['online']).to be false
expect(json_response['runners']['available']).to be false
2018-12-13 13:39:08 +05:30
expect(json_response['stuck']).to be true
2018-12-05 23:21:45 +05:30
end
end
context 'when no runner is online' do
let(:runner) { create(:ci_runner, :instance) }
let(:job) { create(:ci_build, :pending, pipeline: pipeline, runner: runner) }
it 'exposes needed information' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['runners']['online']).to be false
expect(json_response['runners']['available']).to be true
2018-12-13 13:39:08 +05:30
expect(json_response['stuck']).to be true
2018-12-05 23:21:45 +05:30
end
end
context 'settings_path' do
2019-09-04 21:01:54 +05:30
before do
get_show_json
end
2018-12-05 23:21:45 +05:30
context 'when user is developer' do
it 'settings_path is not available' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['runners']).not_to have_key('settings_path')
end
end
context 'when user is maintainer' do
let(:user) { create(:user, :admin) }
before do
project.add_maintainer(user)
sign_in(user)
end
it 'settings_path is available' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['runners']['settings_path']).to match(/runners/)
end
end
end
context 'when no trace is available' do
it 'has_trace is false' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to match_response_schema('job/job_details')
expect(json_response['has_trace']).to be false
end
end
context 'when job has trace' do
let(:job) { create(:ci_build, :running, :trace_live, pipeline: pipeline) }
2020-01-01 13:55:28 +05:30
it "has_trace is true" do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to match_response_schema('job/job_details')
expect(json_response['has_trace']).to be true
end
end
it 'exposes the stage the job belongs to' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(json_response['stage']).to eq('test')
end
end
2019-09-04 21:01:54 +05:30
context 'when requesting triggered job JSON' do
2018-12-05 23:21:45 +05:30
let!(:merge_request) { create(:merge_request, source_project: project) }
let(:trigger) { create(:ci_trigger, project: project) }
let(:trigger_request) { create(:ci_trigger_request, pipeline: pipeline, trigger: trigger) }
let(:job) { create(:ci_build, pipeline: pipeline, trigger_request: trigger_request) }
before do
project.add_developer(user)
sign_in(user)
2019-09-04 21:01:54 +05:30
allow_any_instance_of(Ci::Build)
.to receive(:merge_request)
.and_return(merge_request)
2018-12-05 23:21:45 +05:30
end
context 'with no variables' do
it 'exposes trigger information' do
2019-09-04 21:01:54 +05:30
get_show_json
2018-12-05 23:21:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
expect(json_response['trigger']['short_token']).to eq 'toke'
expect(json_response['trigger']['variables'].length).to eq 0
end
end
context 'with variables' do
before do
create(:ci_pipeline_variable, pipeline: pipeline, key: :TRIGGER_KEY_1, value: 'TRIGGER_VALUE_1')
2019-02-15 15:39:39 +05:30
end
2018-12-23 12:14:25 +05:30
2020-01-01 13:55:28 +05:30
context 'user is a maintainer' do
2019-02-15 15:39:39 +05:30
before do
project.add_maintainer(user)
2019-09-04 21:01:54 +05:30
get_show_json
2019-02-15 15:39:39 +05:30
end
it 'returns a job_detail' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
end
it 'exposes trigger information and variables' do
expect(json_response['trigger']['short_token']).to eq 'toke'
expect(json_response['trigger']['variables'].length).to eq 1
end
it 'exposes correct variable properties' do
first_variable = json_response['trigger']['variables'].first
expect(first_variable['key']).to eq "TRIGGER_KEY_1"
expect(first_variable['value']).to eq "TRIGGER_VALUE_1"
expect(first_variable['public']).to eq false
end
2018-12-05 23:21:45 +05:30
end
2019-02-15 15:39:39 +05:30
context 'user is not a mantainer' do
before do
2019-09-04 21:01:54 +05:30
get_show_json
2019-02-15 15:39:39 +05:30
end
it 'returns a job_detail' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/job_details')
end
it 'exposes trigger information and variables' do
expect(json_response['trigger']['short_token']).to eq 'toke'
expect(json_response['trigger']['variables'].length).to eq 1
end
it 'exposes correct variable properties' do
first_variable = json_response['trigger']['variables'].first
expect(first_variable['key']).to eq "TRIGGER_KEY_1"
expect(first_variable['value']).to be_nil
expect(first_variable['public']).to eq false
end
2018-12-05 23:21:45 +05:30
end
end
2017-08-17 22:00:37 +05:30
end
2019-09-04 21:01:54 +05:30
def get_show_json
expect { get_show(id: job.id, format: :json) }
2020-01-01 13:55:28 +05:30
.to change { Gitlab::GitalyClient.get_request_count }.by_at_most(2)
2019-09-04 21:01:54 +05:30
end
2017-08-17 22:00:37 +05:30
def get_show(**extra_params)
params = {
namespace_id: project.namespace.to_param,
project_id: project
}
2019-02-15 15:39:39 +05:30
get :show, params: params.merge(extra_params)
2017-08-17 22:00:37 +05:30
end
end
describe 'GET trace.json' do
before do
get_trace
end
2018-03-17 18:26:18 +05:30
context 'when job has a trace artifact' do
let(:job) { create(:ci_build, :trace_artifact, pipeline: pipeline) }
it 'returns a trace' do
expect(response).to have_gitlab_http_status(:ok)
2019-12-21 20:55:43 +05:30
expect(response).to match_response_schema('job/build_trace')
2018-03-17 18:26:18 +05:30
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
2019-12-21 20:55:43 +05:30
expect(json_response['state']).to be_present
expect(json_response['append']).not_to be_nil
expect(json_response['truncated']).not_to be_nil
expect(json_response['size']).to be_present
expect(json_response['total']).to be_present
expect(json_response['lines'].count).to be_positive
end
end
context 'when job has a trace' do
let(:job) { create(:ci_build, :trace_live, pipeline: pipeline) }
it 'returns a trace' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/build_trace')
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
expect(json_response['lines']).to eq [{ 'content' => [{ 'text' => 'BUILD TRACE' }], 'offset' => 0 }]
end
2020-03-09 13:42:32 +05:30
it 'sets being-watched flag for the job' do
expect(response).to have_gitlab_http_status(:ok)
expect(job.trace.being_watched?).to be(true)
end
2019-12-21 20:55:43 +05:30
end
context 'when job has no traces' do
let(:job) { create(:ci_build, pipeline: pipeline) }
it 'returns no traces' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/build_trace')
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
expect(json_response['lines']).to be_nil
end
end
context 'when job has a trace with ANSI sequence and Unicode' do
let(:job) { create(:ci_build, :unicode_trace_live, pipeline: pipeline) }
it 'returns a trace with Unicode' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to match_response_schema('job/build_trace')
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
expect(json_response['lines'].flat_map {|l| l['content'].map { |c| c['text'] } }).to include("ヾ(´༎ຶД༎ຶ`)ノ")
end
end
context 'when trace artifact is in ObjectStorage' do
let(:url) { 'http://object-storage/trace' }
let(:file_path) { expand_fixture_path('trace/sample_trace') }
let!(:job) { create(:ci_build, :success, :trace_artifact, pipeline: pipeline) }
before do
allow_any_instance_of(JobArtifactUploader).to receive(:file_storage?) { false }
allow_any_instance_of(JobArtifactUploader).to receive(:url) { url }
allow_any_instance_of(JobArtifactUploader).to receive(:size) { File.size(file_path) }
end
context 'when there are no network issues' do
before do
stub_remote_url_206(url, file_path)
get_trace
end
it 'returns a trace' do
expect(response).to have_gitlab_http_status(:ok)
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
expect(json_response['lines'].count).to be_positive
end
end
context 'when there is a network issue' do
before do
stub_remote_url_500(url)
end
it 'returns a trace' do
expect { get_trace }.to raise_error(Gitlab::HttpIO::FailedToGetChunkError)
end
end
end
def get_trace
get :trace,
params: {
namespace_id: project.namespace,
project_id: project,
id: job.id
},
format: :json
end
end
describe 'GET legacy trace.json' do
before do
2020-01-01 13:55:28 +05:30
stub_feature_flags(job_log_json: false)
2019-12-21 20:55:43 +05:30
get_trace
end
context 'when job has a trace artifact' do
let(:job) { create(:ci_build, :trace_artifact, pipeline: pipeline) }
it 'returns a trace' do
expect(response).to have_gitlab_http_status(:ok)
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
expect(json_response['state']).to be_present
expect(json_response['append']).not_to be_nil
expect(json_response['truncated']).not_to be_nil
expect(json_response['size']).to be_present
expect(json_response['total']).to be_present
2018-03-17 18:26:18 +05:30
expect(json_response['html']).to eq(job.trace.html)
end
end
2017-09-10 17:25:29 +05:30
context 'when job has a trace' do
2018-03-17 18:26:18 +05:30
let(:job) { create(:ci_build, :trace_live, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
it 'returns a trace' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-09-10 17:25:29 +05:30
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
2019-09-30 21:07:59 +05:30
expect(json_response['html']).to eq('<span>BUILD TRACE</span>')
2017-08-17 22:00:37 +05:30
end
end
2017-09-10 17:25:29 +05:30
context 'when job has no traces' do
let(:job) { create(:ci_build, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
it 'returns no traces' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-09-10 17:25:29 +05:30
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
2017-08-17 22:00:37 +05:30
expect(json_response['html']).to be_nil
end
end
2017-09-10 17:25:29 +05:30
context 'when job has a trace with ANSI sequence and Unicode' do
2018-03-17 18:26:18 +05:30
let(:job) { create(:ci_build, :unicode_trace_live, pipeline: pipeline) }
2017-09-10 17:25:29 +05:30
it 'returns a trace with Unicode' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-09-10 17:25:29 +05:30
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
expect(json_response['html']).to include("ヾ(´༎ຶД༎ຶ`)ノ")
end
end
2018-05-09 12:01:36 +05:30
context 'when trace artifact is in ObjectStorage' do
2018-11-18 11:00:15 +05:30
let(:url) { 'http://object-storage/trace' }
let(:file_path) { expand_fixture_path('trace/sample_trace') }
2018-05-09 12:01:36 +05:30
let!(:job) { create(:ci_build, :success, :trace_artifact, pipeline: pipeline) }
before do
allow_any_instance_of(JobArtifactUploader).to receive(:file_storage?) { false }
2018-11-18 11:00:15 +05:30
allow_any_instance_of(JobArtifactUploader).to receive(:url) { url }
allow_any_instance_of(JobArtifactUploader).to receive(:size) { File.size(file_path) }
2018-05-09 12:01:36 +05:30
end
context 'when there are no network issues' do
before do
2018-11-18 11:00:15 +05:30
stub_remote_url_206(url, file_path)
2018-05-09 12:01:36 +05:30
get_trace
end
it 'returns a trace' do
expect(response).to have_gitlab_http_status(:ok)
expect(json_response['id']).to eq job.id
expect(json_response['status']).to eq job.status
expect(json_response['html']).to eq(job.trace.html)
end
end
context 'when there is a network issue' do
before do
2018-11-18 11:00:15 +05:30
stub_remote_url_500(url)
2018-05-09 12:01:36 +05:30
end
it 'returns a trace' do
2018-11-18 11:00:15 +05:30
expect { get_trace }.to raise_error(Gitlab::HttpIO::FailedToGetChunkError)
2018-05-09 12:01:36 +05:30
end
end
end
2017-08-17 22:00:37 +05:30
def get_trace
2019-12-21 20:55:43 +05:30
get :trace,
params: {
namespace_id: project.namespace,
project_id: project,
id: job.id
},
format: :json
2017-08-17 22:00:37 +05:30
end
end
describe 'GET status.json' do
2017-09-10 17:25:29 +05:30
let(:job) { create(:ci_build, pipeline: pipeline) }
let(:status) { job.detailed_status(double('user')) }
2017-08-17 22:00:37 +05:30
before do
2019-02-15 15:39:39 +05:30
get :status, params: {
namespace_id: project.namespace,
project_id: project,
id: job.id
},
2017-08-17 22:00:37 +05:30
format: :json
end
2017-09-10 17:25:29 +05:30
it 'return a detailed job status in json' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-08-17 22:00:37 +05:30
expect(json_response['text']).to eq status.text
expect(json_response['label']).to eq status.label
expect(json_response['icon']).to eq status.icon
2018-11-08 19:23:39 +05:30
expect(json_response['favicon']).to match_asset_path "/assets/ci_favicons/#{status.favicon}.png"
2017-08-17 22:00:37 +05:30
end
end
describe 'POST retry' do
before do
project.add_developer(user)
sign_in(user)
post_retry
end
2017-09-10 17:25:29 +05:30
context 'when job is retryable' do
let(:job) { create(:ci_build, :retryable, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
2017-09-10 17:25:29 +05:30
it 'redirects to the retried job page' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:found)
2017-09-10 17:25:29 +05:30
expect(response).to redirect_to(namespace_project_job_path(id: Ci::Build.last.id))
2017-08-17 22:00:37 +05:30
end
end
2017-09-10 17:25:29 +05:30
context 'when job is not retryable' do
let(:job) { create(:ci_build, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
it 'renders unprocessable_entity' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:unprocessable_entity)
2017-08-17 22:00:37 +05:30
end
end
def post_retry
2019-02-15 15:39:39 +05:30
post :retry, params: {
namespace_id: project.namespace,
project_id: project,
id: job.id
}
2017-08-17 22:00:37 +05:30
end
end
describe 'POST play' do
2019-10-12 21:52:04 +05:30
let(:variable_attributes) { [] }
2017-08-17 22:00:37 +05:30
before do
project.add_developer(user)
create(:protected_branch, :developers_can_merge,
name: 'master', project: project)
sign_in(user)
post_play
end
2017-09-10 17:25:29 +05:30
context 'when job is playable' do
let(:job) { create(:ci_build, :playable, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
2017-09-10 17:25:29 +05:30
it 'redirects to the played job page' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:found)
2017-09-10 17:25:29 +05:30
expect(response).to redirect_to(namespace_project_job_path(id: job.id))
2017-08-17 22:00:37 +05:30
end
it 'transits to pending' do
2017-09-10 17:25:29 +05:30
expect(job.reload).to be_pending
2017-08-17 22:00:37 +05:30
end
2019-10-12 21:52:04 +05:30
context 'when job variables are specified' do
let(:variable_attributes) { [{ key: 'first', secret_value: 'first' }] }
it 'assigns the job variables' do
expect(job.reload.job_variables.map(&:key)).to contain_exactly('first')
end
end
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
context 'when job is not playable' do
let(:job) { create(:ci_build, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
it 'renders unprocessable_entity' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:unprocessable_entity)
2017-08-17 22:00:37 +05:30
end
end
def post_play
2019-02-15 15:39:39 +05:30
post :play, params: {
namespace_id: project.namespace,
project_id: project,
2019-10-12 21:52:04 +05:30
id: job.id,
job_variables_attributes: variable_attributes
2019-02-15 15:39:39 +05:30
}
2017-08-17 22:00:37 +05:30
end
end
describe 'POST cancel' do
before do
project.add_developer(user)
sign_in(user)
end
2018-12-13 13:39:08 +05:30
context 'when continue url is present' do
2017-09-10 17:25:29 +05:30
let(:job) { create(:ci_build, :cancelable, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
2018-12-13 13:39:08 +05:30
context 'when continue to is a safe url' do
let(:url) { '/test' }
before do
post_cancel(continue: { to: url })
end
it 'redirects to the continue url' do
expect(response).to have_gitlab_http_status(:found)
expect(response).to redirect_to(url)
end
it 'transits to canceled' do
expect(job.reload).to be_canceled
end
2017-08-17 22:00:37 +05:30
end
2018-12-13 13:39:08 +05:30
context 'when continue to is not a safe url' do
let(:url) { 'http://example.com' }
it 'raises an error' do
expect { cancel_with_redirect(url) }.to raise_error
end
2017-08-17 22:00:37 +05:30
end
end
2018-12-13 13:39:08 +05:30
context 'when continue url is not present' do
before do
post_cancel
end
2017-08-17 22:00:37 +05:30
2018-12-13 13:39:08 +05:30
context 'when job is cancelable' do
let(:job) { create(:ci_build, :cancelable, pipeline: pipeline) }
it 'redirects to the builds page' do
expect(response).to have_gitlab_http_status(:found)
expect(response).to redirect_to(builds_namespace_project_pipeline_path(id: pipeline.id))
end
it 'transits to canceled' do
expect(job.reload).to be_canceled
end
end
context 'when job is not cancelable' do
let(:job) { create(:ci_build, :canceled, pipeline: pipeline) }
it 'returns unprocessable_entity' do
expect(response).to have_gitlab_http_status(:unprocessable_entity)
end
2017-08-17 22:00:37 +05:30
end
end
2018-12-13 13:39:08 +05:30
def post_cancel(additional_params = {})
2019-02-15 15:39:39 +05:30
post :cancel, params: { namespace_id: project.namespace,
project_id: project,
id: job.id }.merge(additional_params)
2017-08-17 22:00:37 +05:30
end
end
2018-12-05 23:21:45 +05:30
describe 'POST unschedule' do
before do
project.add_developer(user)
create(:protected_branch, :developers_can_merge,
name: 'master', project: project)
sign_in(user)
post_unschedule
end
context 'when job is scheduled' do
let(:job) { create(:ci_build, :scheduled, pipeline: pipeline) }
it 'redirects to the unscheduled job page' do
expect(response).to have_gitlab_http_status(:found)
expect(response).to redirect_to(namespace_project_job_path(id: job.id))
end
it 'transits to manual' do
expect(job.reload).to be_manual
end
end
context 'when job is not scheduled' do
let(:job) { create(:ci_build, pipeline: pipeline) }
it 'renders unprocessable_entity' do
expect(response).to have_gitlab_http_status(:unprocessable_entity)
end
end
def post_unschedule
2019-02-15 15:39:39 +05:30
post :unschedule, params: {
namespace_id: project.namespace,
project_id: project,
id: job.id
}
2018-12-05 23:21:45 +05:30
end
end
2017-08-17 22:00:37 +05:30
describe 'POST erase' do
2018-11-18 11:00:15 +05:30
let(:role) { :maintainer }
2018-03-17 18:26:18 +05:30
2017-08-17 22:00:37 +05:30
before do
2018-03-17 18:26:18 +05:30
project.add_role(user, role)
2017-08-17 22:00:37 +05:30
sign_in(user)
post_erase
end
2017-09-10 17:25:29 +05:30
context 'when job is erasable' do
2018-03-17 18:26:18 +05:30
let(:job) { create(:ci_build, :erasable, :trace_artifact, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
2017-09-10 17:25:29 +05:30
it 'redirects to the erased job page' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:found)
2017-09-10 17:25:29 +05:30
expect(response).to redirect_to(namespace_project_job_path(id: job.id))
2017-08-17 22:00:37 +05:30
end
it 'erases artifacts' do
2019-09-04 21:01:54 +05:30
expect(job.artifacts_file.present?).to be_falsey
expect(job.artifacts_metadata.present?).to be_falsey
2017-08-17 22:00:37 +05:30
end
it 'erases trace' do
2017-09-10 17:25:29 +05:30
expect(job.trace.exist?).to be_falsey
2017-08-17 22:00:37 +05:30
end
end
2017-09-10 17:25:29 +05:30
context 'when job is not erasable' do
let(:job) { create(:ci_build, :erased, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
it 'returns unprocessable_entity' do
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:unprocessable_entity)
end
end
context 'when user is developer' do
let(:role) { :developer }
let(:job) { create(:ci_build, :erasable, :trace_artifact, pipeline: pipeline, user: triggered_by) }
context 'when triggered by same user' do
let(:triggered_by) { user }
it 'has successful status' do
expect(response).to have_gitlab_http_status(:found)
end
end
context 'when triggered by different user' do
let(:triggered_by) { create(:user) }
it 'does not have successful status' do
expect(response).not_to have_gitlab_http_status(:found)
end
2017-08-17 22:00:37 +05:30
end
end
def post_erase
2019-02-15 15:39:39 +05:30
post :erase, params: {
namespace_id: project.namespace,
project_id: project,
id: job.id
}
2017-08-17 22:00:37 +05:30
end
end
describe 'GET raw' do
2018-05-09 12:01:36 +05:30
subject do
2019-02-15 15:39:39 +05:30
post :raw, params: {
namespace_id: project.namespace,
project_id: project,
id: job.id
}
2017-08-17 22:00:37 +05:30
end
2018-11-08 19:23:39 +05:30
context "when job has a trace artifact" do
2018-03-17 18:26:18 +05:30
let(:job) { create(:ci_build, :trace_artifact, pipeline: pipeline) }
2019-02-15 15:39:39 +05:30
it "sets #{Gitlab::Workhorse::DETECT_HEADER} header" do
2019-01-03 12:48:30 +05:30
response = subject
2018-12-23 12:14:25 +05:30
2019-01-03 12:48:30 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(response.headers["Content-Type"]).to eq("text/plain; charset=utf-8")
expect(response.body).to eq(job.job_artifacts_trace.open.read)
2019-02-15 15:39:39 +05:30
expect(response.header[Gitlab::Workhorse::DETECT_HEADER]).to eq "true"
2018-03-17 18:26:18 +05:30
end
end
2018-11-08 19:23:39 +05:30
context "when job has a trace file" do
2018-03-17 18:26:18 +05:30
let(:job) { create(:ci_build, :trace_live, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
2019-02-15 15:39:39 +05:30
it 'sends a trace file' do
2018-05-09 12:01:36 +05:30
response = subject
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:ok)
2018-11-08 19:23:39 +05:30
expect(response.headers["Content-Type"]).to eq("text/plain; charset=utf-8")
2019-02-15 15:39:39 +05:30
expect(response.headers["Content-Disposition"]).to match(/^inline/)
2018-11-08 19:23:39 +05:30
expect(response.body).to eq("BUILD TRACE")
2017-08-17 22:00:37 +05:30
end
end
2018-11-08 19:23:39 +05:30
context "when job has a trace in database" do
2018-05-09 12:01:36 +05:30
let(:job) { create(:ci_build, pipeline: pipeline) }
before do
2018-11-08 19:23:39 +05:30
job.update_column(:trace, "Sample trace")
2018-05-09 12:01:36 +05:30
end
2019-02-15 15:39:39 +05:30
it 'sends a trace file' do
2018-05-09 12:01:36 +05:30
response = subject
expect(response).to have_gitlab_http_status(:ok)
2019-02-15 15:39:39 +05:30
expect(response.headers['Content-Type']).to eq('text/plain; charset=utf-8')
expect(response.headers['Content-Disposition']).to match(/^inline/)
expect(response.body).to eq('Sample trace')
end
context 'when trace format is not text/plain' do
before do
job.update_column(:trace, '<html></html>')
end
it 'sets content disposition to attachment' do
response = subject
expect(response).to have_gitlab_http_status(:ok)
expect(response.headers['Content-Type']).to eq('text/plain; charset=utf-8')
expect(response.headers['Content-Disposition']).to match(/^attachment/)
end
2018-05-09 12:01:36 +05:30
end
end
2017-09-10 17:25:29 +05:30
context 'when job does not have a trace file' do
let(:job) { create(:ci_build, pipeline: pipeline) }
2017-08-17 22:00:37 +05:30
it 'returns not_found' do
2018-05-09 12:01:36 +05:30
response = subject
expect(response).to have_gitlab_http_status(:ok)
expect(response.body).to eq ''
2017-08-17 22:00:37 +05:30
end
end
2018-05-09 12:01:36 +05:30
context 'when the trace artifact is in ObjectStorage' do
let!(:job) { create(:ci_build, :trace_artifact, pipeline: pipeline) }
before do
allow_any_instance_of(JobArtifactUploader).to receive(:file_storage?) { false }
end
it 'redirect to the trace file url' do
expect(subject).to redirect_to(job.job_artifacts_trace.file.url)
end
2017-08-17 22:00:37 +05:30
end
end
2018-11-08 19:23:39 +05:30
describe 'GET #terminal' do
before do
project.add_developer(user)
sign_in(user)
end
context 'when job exists' do
context 'and it has a terminal' do
let!(:job) { create(:ci_build, :running, :with_runner_session, pipeline: pipeline) }
it 'has a job' do
get_terminal(id: job.id)
expect(response).to have_gitlab_http_status(:ok)
expect(assigns(:build).id).to eq(job.id)
end
end
context 'and does not have a terminal' do
let!(:job) { create(:ci_build, :running, pipeline: pipeline) }
it 'returns not_found' do
get_terminal(id: job.id)
expect(response).to have_gitlab_http_status(:not_found)
end
end
end
context 'when job does not exist' do
it 'renders not_found' do
get_terminal(id: 1234)
expect(response).to have_gitlab_http_status(:not_found)
end
end
def get_terminal(**extra_params)
params = {
namespace_id: project.namespace.to_param,
project_id: project
}
2019-02-15 15:39:39 +05:30
get :terminal, params: params.merge(extra_params)
2018-11-08 19:23:39 +05:30
end
end
describe 'GET #terminal_websocket_authorize' do
let!(:job) { create(:ci_build, :running, :with_runner_session, pipeline: pipeline) }
before do
project.add_developer(user)
sign_in(user)
end
context 'with valid workhorse signature' do
before do
allow(Gitlab::Workhorse).to receive(:verify_api_request!).and_return(nil)
end
context 'and valid id' do
it 'returns the terminal for the job' do
expect(Gitlab::Workhorse)
2019-07-07 11:18:12 +05:30
.to receive(:channel_websocket)
2018-11-08 19:23:39 +05:30
.and_return(workhorse: :response)
get_terminal_websocket(id: job.id)
2020-03-09 13:42:32 +05:30
expect(response).to have_gitlab_http_status(:ok)
2018-11-08 19:23:39 +05:30
expect(response.headers["Content-Type"]).to eq(Gitlab::Workhorse::INTERNAL_API_CONTENT_TYPE)
expect(response.body).to eq('{"workhorse":"response"}')
end
end
context 'and invalid id' do
it 'returns 404' do
get_terminal_websocket(id: 1234)
2020-03-09 13:42:32 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2018-11-08 19:23:39 +05:30
end
end
end
context 'with invalid workhorse signature' do
it 'aborts with an exception' do
allow(Gitlab::Workhorse).to receive(:verify_api_request!).and_raise(JWT::DecodeError)
expect { get_terminal_websocket(id: job.id) }.to raise_error(JWT::DecodeError)
end
end
def get_terminal_websocket(**extra_params)
params = {
namespace_id: project.namespace.to_param,
project_id: project
}
2019-02-15 15:39:39 +05:30
get :terminal_websocket_authorize, params: params.merge(extra_params)
2018-11-08 19:23:39 +05:30
end
end
2017-08-17 22:00:37 +05:30
end