debian-mirror-gitlab/spec/requests/api/ci/pipelines_spec.rb

1099 lines
39 KiB
Ruby
Raw Normal View History

2019-07-31 22:56:46 +05:30
# frozen_string_literal: true
2016-09-13 17:45:13 +05:30
require 'spec_helper'
2020-07-28 23:09:34 +05:30
RSpec.describe API::Ci::Pipelines do
2020-04-22 19:07:51 +05:30
let_it_be(:user) { create(:user) }
let_it_be(:non_member) { create(:user) }
2020-11-24 15:15:51 +05:30
let_it_be(:project2) { create(:project, creator: user) }
2016-09-13 17:45:13 +05:30
2020-04-22 19:07:51 +05:30
# We need to reload as the shared example 'pipelines visibility table' is changing project
let_it_be(:project, reload: true) do
create(:project, :repository, creator: user)
end
let_it_be(:pipeline) do
2016-09-13 17:45:13 +05:30
create(:ci_empty_pipeline, project: project, sha: project.commit.id,
2017-09-10 17:25:29 +05:30
ref: project.default_branch, user: user)
2016-09-13 17:45:13 +05:30
end
2017-09-10 17:25:29 +05:30
before do
2018-11-18 11:00:15 +05:30
project.add_maintainer(user)
2017-09-10 17:25:29 +05:30
end
2016-09-13 17:45:13 +05:30
describe 'GET /projects/:id/pipelines ' do
2019-12-04 20:38:33 +05:30
it_behaves_like 'pipelines visibility table'
2016-09-13 17:45:13 +05:30
context 'authorized user' do
it 'returns project pipelines' do
get api("/projects/#{project.id}/pipelines", user)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2017-08-17 22:00:37 +05:30
expect(response).to include_pagination_headers
2016-09-13 17:45:13 +05:30
expect(json_response).to be_an Array
2020-04-22 19:07:51 +05:30
expect(json_response.first['sha']).to match(/\A\h{40}\z/)
2016-09-13 17:45:13 +05:30
expect(json_response.first['id']).to eq pipeline.id
2018-11-18 11:00:15 +05:30
expect(json_response.first['web_url']).to be_present
2019-12-21 20:55:43 +05:30
expect(json_response.first.keys).to contain_exactly(*%w[id sha ref status web_url created_at updated_at])
2017-08-17 22:00:37 +05:30
end
context 'when parameter is passed' do
%w[running pending].each do |target|
context "when scope is #{target}" do
before do
create(:ci_pipeline, project: project, status: target)
end
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { scope: target }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).not_to be_empty
json_response.each { |r| expect(r['status']).to eq(target) }
end
end
end
context 'when scope is finished' do
before do
create(:ci_pipeline, project: project, status: 'success')
create(:ci_pipeline, project: project, status: 'failed')
create(:ci_pipeline, project: project, status: 'canceled')
end
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { scope: 'finished' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).not_to be_empty
json_response.each { |r| expect(r['status']).to be_in(%w[success failed canceled]) }
end
end
context 'when scope is branches or tags' do
2020-05-24 23:13:21 +05:30
let_it_be(:pipeline_branch) { create(:ci_pipeline, project: project) }
let_it_be(:pipeline_tag) { create(:ci_pipeline, project: project, ref: 'v1.0.0', tag: true) }
2017-08-17 22:00:37 +05:30
context 'when scope is branches' do
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { scope: 'branches' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).not_to be_empty
expect(json_response.last['id']).to eq(pipeline_branch.id)
end
end
context 'when scope is tags' do
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { scope: 'tags' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).not_to be_empty
expect(json_response.last['id']).to eq(pipeline_tag.id)
end
end
end
context 'when scope is invalid' do
it 'returns bad_request' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { scope: 'invalid-scope' }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2017-08-17 22:00:37 +05:30
end
end
2020-07-28 23:09:34 +05:30
Ci::HasStatus::AVAILABLE_STATUSES.each do |target|
2017-08-17 22:00:37 +05:30
context "when status is #{target}" do
before do
create(:ci_pipeline, project: project, status: target)
2020-07-28 23:09:34 +05:30
exception_status = Ci::HasStatus::AVAILABLE_STATUSES - [target]
2017-08-17 22:00:37 +05:30
create(:ci_pipeline, project: project, status: exception_status.sample)
end
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { status: target }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).not_to be_empty
json_response.each { |r| expect(r['status']).to eq(target) }
end
end
end
context 'when status is invalid' do
it 'returns bad_request' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { status: 'invalid-status' }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2017-08-17 22:00:37 +05:30
end
end
context 'when ref is specified' do
before do
create(:ci_pipeline, project: project)
end
context 'when ref exists' do
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { ref: 'master' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).not_to be_empty
json_response.each { |r| expect(r['ref']).to eq('master') }
end
end
context 'when ref does not exist' do
it 'returns empty' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { ref: 'invalid-ref' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).to be_empty
end
end
end
context 'when name is specified' do
2020-05-24 23:13:21 +05:30
let_it_be(:pipeline) { create(:ci_pipeline, project: project, user: user) }
2017-08-17 22:00:37 +05:30
context 'when name exists' do
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { name: user.name }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response.first['id']).to eq(pipeline.id)
end
end
context 'when name does not exist' do
it 'returns empty' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { name: 'invalid-name' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).to be_empty
end
end
end
context 'when username is specified' do
2020-05-24 23:13:21 +05:30
let_it_be(:pipeline) { create(:ci_pipeline, project: project, user: user) }
2017-08-17 22:00:37 +05:30
context 'when username exists' do
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { username: user.username }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response.first['id']).to eq(pipeline.id)
end
end
context 'when username does not exist' do
it 'returns empty' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { username: 'invalid-username' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).to be_empty
end
end
end
context 'when yaml_errors is specified' do
2020-05-24 23:13:21 +05:30
let_it_be(:pipeline1) { create(:ci_pipeline, project: project, yaml_errors: 'Syntax error') }
let_it_be(:pipeline2) { create(:ci_pipeline, project: project) }
2017-08-17 22:00:37 +05:30
context 'when yaml_errors is true' do
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { yaml_errors: true }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response.first['id']).to eq(pipeline1.id)
end
end
context 'when yaml_errors is false' do
it 'returns matched pipelines' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { yaml_errors: false }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response.first['id']).to eq(pipeline2.id)
end
end
context 'when yaml_errors is invalid' do
it 'returns bad_request' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { yaml_errors: 'invalid-yaml_errors' }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2017-08-17 22:00:37 +05:30
end
end
end
2020-01-01 13:55:28 +05:30
context 'when updated_at filters are specified' do
2020-05-24 23:13:21 +05:30
let_it_be(:pipeline1) { create(:ci_pipeline, project: project, updated_at: 2.days.ago) }
let_it_be(:pipeline2) { create(:ci_pipeline, project: project, updated_at: 4.days.ago) }
let_it_be(:pipeline3) { create(:ci_pipeline, project: project, updated_at: 1.hour.ago) }
2020-01-01 13:55:28 +05:30
it 'returns pipelines with last update date in specified datetime range' do
get api("/projects/#{project.id}/pipelines", user), params: { updated_before: 1.day.ago, updated_after: 3.days.ago }
expect(response).to have_gitlab_http_status(:ok)
expect(response).to include_pagination_headers
expect(json_response.first['id']).to eq(pipeline1.id)
end
end
2017-08-17 22:00:37 +05:30
context 'when order_by and sort are specified' do
context 'when order_by user_id' do
2017-09-10 17:25:29 +05:30
before do
2020-04-08 14:13:33 +05:30
create_list(:user, 3).each do |some_user|
create(:ci_pipeline, project: project, user: some_user)
end
2017-09-10 17:25:29 +05:30
end
2017-08-17 22:00:37 +05:30
2017-09-10 17:25:29 +05:30
context 'when sort parameter is valid' do
it 'sorts as user_id: :desc' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { order_by: 'user_id', sort: 'desc' }
2017-08-17 22:00:37 +05:30
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(response).to include_pagination_headers
expect(json_response).not_to be_empty
pipeline_ids = Ci::Pipeline.all.order(user_id: :desc).pluck(:id)
expect(json_response.map { |r| r['id'] }).to eq(pipeline_ids)
2017-08-17 22:00:37 +05:30
end
end
2017-09-10 17:25:29 +05:30
context 'when sort parameter is invalid' do
2017-08-17 22:00:37 +05:30
it 'returns bad_request' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { order_by: 'user_id', sort: 'invalid_sort' }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2017-08-17 22:00:37 +05:30
end
end
end
context 'when order_by is invalid' do
it 'returns bad_request' do
2019-02-15 15:39:39 +05:30
get api("/projects/#{project.id}/pipelines", user), params: { order_by: 'lock_version', sort: 'asc' }
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2017-08-17 22:00:37 +05:30
end
end
end
2016-09-13 17:45:13 +05:30
end
end
context 'unauthorized user' do
it 'does not return project pipelines' do
get api("/projects/#{project.id}/pipelines", non_member)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2016-09-13 17:45:13 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(json_response).not_to be_an Array
end
end
end
2020-11-24 15:15:51 +05:30
describe 'GET /projects/:id/pipelines/:pipeline_id/jobs' do
let(:query) { {} }
let(:api_user) { user }
let_it_be(:job) do
create(:ci_build, :success, pipeline: pipeline,
artifacts_expire_at: 1.day.since)
end
let(:guest) { create(:project_member, :guest, project: project).user }
before do |example|
unless example.metadata[:skip_before_request]
project.update!(public_builds: false)
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/jobs", api_user), params: query
end
end
2021-01-29 00:20:46 +05:30
context 'authorized user' do
it 'returns pipeline jobs' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to include_pagination_headers
expect(json_response).to be_an Array
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
it 'returns correct values' do
expect(json_response).not_to be_empty
expect(json_response.first['commit']['id']).to eq project.commit.id
expect(Time.parse(json_response.first['artifacts_expire_at'])).to be_like_time(job.artifacts_expire_at)
expect(json_response.first['artifacts_file']).to be_nil
expect(json_response.first['artifacts']).to be_an Array
expect(json_response.first['artifacts']).to be_empty
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
it_behaves_like 'a job with artifacts and trace' do
let(:api_endpoint) { "/projects/#{project.id}/pipelines/#{pipeline.id}/jobs" }
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
it 'returns pipeline data' do
json_job = json_response.first
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect(json_job['pipeline']).not_to be_empty
expect(json_job['pipeline']['id']).to eq job.pipeline.id
expect(json_job['pipeline']['ref']).to eq job.pipeline.ref
expect(json_job['pipeline']['sha']).to eq job.pipeline.sha
expect(json_job['pipeline']['status']).to eq job.pipeline.status
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
context 'filter jobs with one scope element' do
let(:query) { { 'scope' => 'pending' } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it do
2020-11-24 15:15:51 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response).to be_an Array
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'filter jobs with hash' do
let(:query) { { scope: { hello: 'pending', world: 'running' } } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it { expect(response).to have_gitlab_http_status(:bad_request) }
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'filter jobs with array of scope elements' do
let(:query) { { scope: %w(pending running) } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it do
expect(response).to have_gitlab_http_status(:ok)
expect(json_response).to be_an Array
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'respond 400 when scope contains invalid state' do
let(:query) { { scope: %w(unknown running) } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it { expect(response).to have_gitlab_http_status(:bad_request) }
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'jobs in different pipelines' do
let!(:pipeline2) { create(:ci_empty_pipeline, project: project) }
let!(:job2) { create(:ci_build, pipeline: pipeline2) }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'excludes jobs from other pipelines' do
json_response.each { |job| expect(job['pipeline']['id']).to eq(pipeline.id) }
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'avoids N+1 queries' do
control_count = ActiveRecord::QueryRecorder.new(skip_cached: false) do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/jobs", api_user), params: query
end.count
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
create_list(:ci_build, 3, :trace_artifact, :artifacts, :test_reports, pipeline: pipeline)
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/jobs", api_user), params: query
end.not_to exceed_all_query_limit(control_count)
end
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'no pipeline is found' do
it 'does not return jobs' do
get api("/projects/#{project2.id}/pipelines/#{pipeline.id}/jobs", user)
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(response).to have_gitlab_http_status(:not_found)
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'unauthorized user' do
context 'when user is not logged in' do
let(:api_user) { nil }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'does not return jobs' do
2020-11-24 15:15:51 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(response).to have_gitlab_http_status(:not_found)
end
end
2021-01-29 00:20:46 +05:30
context 'when user is guest' do
let(:guest) { create(:project_member, :guest, project: project).user }
let(:api_user) { guest }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'does not return jobs' do
expect(response).to have_gitlab_http_status(:forbidden)
2020-11-24 15:15:51 +05:30
end
end
end
end
describe 'GET /projects/:id/pipelines/:pipeline_id/bridges' do
let_it_be(:bridge) { create(:ci_bridge, pipeline: pipeline) }
let(:downstream_pipeline) { create(:ci_pipeline) }
let!(:pipeline_source) do
create(:ci_sources_pipeline,
source_pipeline: pipeline,
source_project: project,
source_job: bridge,
pipeline: downstream_pipeline,
project: downstream_pipeline.project)
end
let(:query) { {} }
let(:api_user) { user }
before do |example|
unless example.metadata[:skip_before_request]
project.update!(public_builds: false)
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
end
end
2021-01-29 00:20:46 +05:30
context 'authorized user' do
it 'returns pipeline bridges' do
expect(response).to have_gitlab_http_status(:ok)
expect(response).to include_pagination_headers
expect(json_response).to be_an Array
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
it 'returns correct values' do
expect(json_response).not_to be_empty
expect(json_response.first['commit']['id']).to eq project.commit.id
expect(json_response.first['id']).to eq bridge.id
expect(json_response.first['name']).to eq bridge.name
expect(json_response.first['stage']).to eq bridge.stage
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'returns pipeline data' do
json_bridge = json_response.first
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect(json_bridge['pipeline']).not_to be_empty
expect(json_bridge['pipeline']['id']).to eq bridge.pipeline.id
expect(json_bridge['pipeline']['ref']).to eq bridge.pipeline.ref
expect(json_bridge['pipeline']['sha']).to eq bridge.pipeline.sha
expect(json_bridge['pipeline']['status']).to eq bridge.pipeline.status
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'returns downstream pipeline data' do
json_bridge = json_response.first
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect(json_bridge['downstream_pipeline']).not_to be_empty
expect(json_bridge['downstream_pipeline']['id']).to eq downstream_pipeline.id
expect(json_bridge['downstream_pipeline']['ref']).to eq downstream_pipeline.ref
expect(json_bridge['downstream_pipeline']['sha']).to eq downstream_pipeline.sha
expect(json_bridge['downstream_pipeline']['status']).to eq downstream_pipeline.status
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'filter bridges' do
before_all do
create_bridge(pipeline, :pending)
create_bridge(pipeline, :running)
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
context 'with one scope element' do
let(:query) { { 'scope' => 'pending' } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it :skip_before_request do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response).to be_an Array
expect(json_response.count).to eq 1
expect(json_response.first["status"]).to eq "pending"
2020-11-24 15:15:51 +05:30
end
end
2021-01-29 00:20:46 +05:30
context 'with array of scope elements' do
let(:query) { { scope: %w(pending running) } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it :skip_before_request do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response).to be_an Array
expect(json_response.count).to eq 2
json_response.each { |r| expect(%w(pending running).include?(r['status'])).to be true }
2020-11-24 15:15:51 +05:30
end
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'respond 400 when scope contains invalid state' do
context 'in an array' do
let(:query) { { scope: %w(unknown running) } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it { expect(response).to have_gitlab_http_status(:bad_request) }
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
context 'in a hash' do
let(:query) { { scope: { unknown: true } } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it { expect(response).to have_gitlab_http_status(:bad_request) }
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
context 'in a string' do
let(:query) { { scope: "unknown" } }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it { expect(response).to have_gitlab_http_status(:bad_request) }
2020-11-24 15:15:51 +05:30
end
end
2021-01-29 00:20:46 +05:30
context 'bridges in different pipelines' do
let!(:pipeline2) { create(:ci_empty_pipeline, project: project) }
let!(:bridge2) { create(:ci_bridge, pipeline: pipeline2) }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'excludes bridges from other pipelines' do
json_response.each { |bridge| expect(bridge['pipeline']['id']).to eq(pipeline.id) }
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'avoids N+1 queries' do
control_count = ActiveRecord::QueryRecorder.new(skip_cached: false) do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
end.count
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
3.times { create_bridge(pipeline) }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
end.not_to exceed_all_query_limit(control_count)
2020-11-24 15:15:51 +05:30
end
end
2021-01-29 00:20:46 +05:30
context 'no pipeline is found' do
it 'does not return bridges' do
get api("/projects/#{project2.id}/pipelines/#{pipeline.id}/bridges", user)
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(response).to have_gitlab_http_status(:not_found)
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'unauthorized user' do
context 'when user is not logged in' do
let(:api_user) { nil }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'does not return bridges' do
2020-11-24 15:15:51 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(response).to have_gitlab_http_status(:not_found)
end
end
2021-01-29 00:20:46 +05:30
context 'when user is guest' do
let(:api_user) { guest }
let(:guest) { create(:project_member, :guest, project: project).user }
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
it 'does not return bridges' do
expect(response).to have_gitlab_http_status(:forbidden)
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
end
2020-11-24 15:15:51 +05:30
2021-01-29 00:20:46 +05:30
context 'when user has no read_build access for project' do
before do
project.add_guest(api_user)
2020-11-24 15:15:51 +05:30
end
2021-01-29 00:20:46 +05:30
it 'does not return bridges' do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user)
expect(response).to have_gitlab_http_status(:forbidden)
2020-11-24 15:15:51 +05:30
end
end
end
def create_bridge(pipeline, status = :created)
create(:ci_bridge, status: status, pipeline: pipeline).tap do |bridge|
downstream_pipeline = create(:ci_pipeline)
create(:ci_sources_pipeline,
source_pipeline: pipeline,
source_project: pipeline.project,
source_job: bridge,
pipeline: downstream_pipeline,
project: downstream_pipeline.project)
end
end
end
2017-08-17 22:00:37 +05:30
describe 'POST /projects/:id/pipeline ' do
2018-11-08 19:23:39 +05:30
def expect_variables(variables, expected_variables)
variables.each_with_index do |variable, index|
expected_variable = expected_variables[index]
expect(variable.key).to eq(expected_variable['key'])
expect(variable.value).to eq(expected_variable['value'])
2019-07-31 22:56:46 +05:30
expect(variable.variable_type).to eq(expected_variable['variable_type'])
2018-11-08 19:23:39 +05:30
end
end
2017-08-17 22:00:37 +05:30
context 'authorized user' do
context 'with gitlab-ci.yml' do
2017-09-10 17:25:29 +05:30
before do
stub_ci_pipeline_to_return_yaml_file
end
2017-08-17 22:00:37 +05:30
it 'creates and returns a new pipeline' do
expect do
2019-02-15 15:39:39 +05:30
post api("/projects/#{project.id}/pipeline", user), params: { ref: project.default_branch }
end.to change { project.ci_pipelines.count }.by(1)
2017-08-17 22:00:37 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:created)
2017-08-17 22:00:37 +05:30
expect(json_response).to be_a Hash
expect(json_response['sha']).to eq project.commit.id
end
2018-11-08 19:23:39 +05:30
context 'variables given' do
2019-07-31 22:56:46 +05:30
let(:variables) { [{ 'variable_type' => 'file', 'key' => 'UPLOAD_TO_S3', 'value' => 'true' }] }
2018-11-08 19:23:39 +05:30
it 'creates and returns a new pipeline using the given variables' do
expect do
2019-02-15 15:39:39 +05:30
post api("/projects/#{project.id}/pipeline", user), params: { ref: project.default_branch, variables: variables }
end.to change { project.ci_pipelines.count }.by(1)
expect_variables(project.ci_pipelines.last.variables, variables)
2018-11-08 19:23:39 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:created)
2018-11-08 19:23:39 +05:30
expect(json_response).to be_a Hash
expect(json_response['sha']).to eq project.commit.id
expect(json_response).not_to have_key('variables')
end
end
describe 'using variables conditions' do
2019-07-31 22:56:46 +05:30
let(:variables) { [{ 'variable_type' => 'env_var', 'key' => 'STAGING', 'value' => 'true' }] }
2018-11-08 19:23:39 +05:30
before do
config = YAML.dump(test: { script: 'test', only: { variables: ['$STAGING'] } })
stub_ci_pipeline_yaml_file(config)
end
it 'creates and returns a new pipeline using the given variables' do
expect do
2019-02-15 15:39:39 +05:30
post api("/projects/#{project.id}/pipeline", user), params: { ref: project.default_branch, variables: variables }
end.to change { project.ci_pipelines.count }.by(1)
expect_variables(project.ci_pipelines.last.variables, variables)
2018-11-08 19:23:39 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:created)
2018-11-08 19:23:39 +05:30
expect(json_response).to be_a Hash
expect(json_response['sha']).to eq project.commit.id
expect(json_response).not_to have_key('variables')
end
context 'condition unmatch' do
let(:variables) { [{ 'key' => 'STAGING', 'value' => 'false' }] }
it "doesn't create a job" do
expect do
2019-02-15 15:39:39 +05:30
post api("/projects/#{project.id}/pipeline", user), params: { ref: project.default_branch }
end.not_to change { project.ci_pipelines.count }
2018-11-08 19:23:39 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2018-11-08 19:23:39 +05:30
end
end
end
2017-08-17 22:00:37 +05:30
it 'fails when using an invalid ref' do
2019-02-15 15:39:39 +05:30
post api("/projects/#{project.id}/pipeline", user), params: { ref: 'invalid_ref' }
2017-08-17 22:00:37 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2017-08-17 22:00:37 +05:30
expect(json_response['message']['base'].first).to eq 'Reference not found'
expect(json_response).not_to be_an Array
end
end
context 'without gitlab-ci.yml' do
2018-11-20 20:47:30 +05:30
context 'without auto devops enabled' do
before do
project.update!(auto_devops_attributes: { enabled: false })
end
2017-08-17 22:00:37 +05:30
2018-11-20 20:47:30 +05:30
it 'fails to create pipeline' do
2019-02-15 15:39:39 +05:30
post api("/projects/#{project.id}/pipeline", user), params: { ref: project.default_branch }
2018-11-20 20:47:30 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:bad_request)
2020-01-01 13:55:28 +05:30
expect(json_response['message']['base'].first).to eq 'Missing CI config file'
2018-11-20 20:47:30 +05:30
expect(json_response).not_to be_an Array
end
2017-08-17 22:00:37 +05:30
end
end
end
context 'unauthorized user' do
it 'does not create pipeline' do
2019-02-15 15:39:39 +05:30
post api("/projects/#{project.id}/pipeline", non_member), params: { ref: project.default_branch }
2017-08-17 22:00:37 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2017-08-17 22:00:37 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(json_response).not_to be_an Array
end
end
end
2016-09-13 17:45:13 +05:30
describe 'GET /projects/:id/pipelines/:pipeline_id' do
2019-12-04 20:38:33 +05:30
it_behaves_like 'pipelines visibility table' do
let(:pipelines_api_path) do
"/projects/#{project.id}/pipelines/#{pipeline.id}"
end
let(:api_response) { response_status == 200 ? response : json_response }
let(:response_200) { match_response_schema('public_api/v4/pipeline/detail') }
end
2016-09-13 17:45:13 +05:30
context 'authorized user' do
2019-07-07 11:18:12 +05:30
it 'exposes known attributes' do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}", user)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2019-07-07 11:18:12 +05:30
expect(response).to match_response_schema('public_api/v4/pipeline/detail')
end
2020-10-24 23:57:45 +05:30
it 'returns project pipeline' do
2016-09-13 17:45:13 +05:30
get api("/projects/#{project.id}/pipelines/#{pipeline.id}", user)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2020-04-22 19:07:51 +05:30
expect(json_response['sha']).to match(/\A\h{40}\z/)
2016-09-13 17:45:13 +05:30
end
it 'returns 404 when it does not exist' do
2020-04-22 19:07:51 +05:30
get api("/projects/#{project.id}/pipelines/#{non_existing_record_id}", user)
2016-09-13 17:45:13 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2016-09-13 17:45:13 +05:30
expect(json_response['message']).to eq '404 Not found'
expect(json_response['id']).to be nil
end
2017-08-17 22:00:37 +05:30
context 'with coverage' do
before do
create(:ci_build, coverage: 30, pipeline: pipeline)
end
it 'exposes the coverage' do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}", user)
expect(json_response["coverage"].to_i).to eq(30)
end
end
2016-09-13 17:45:13 +05:30
end
context 'unauthorized user' do
2019-07-07 11:18:12 +05:30
it 'does not return a project pipeline' do
2016-09-13 17:45:13 +05:30
get api("/projects/#{project.id}/pipelines/#{pipeline.id}", non_member)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2016-09-13 17:45:13 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(json_response['id']).to be nil
end
end
2020-10-24 23:57:45 +05:30
2020-11-24 15:15:51 +05:30
context 'when pipeline is a dangling pipeline' do
let(:dangling_source) { Enums::Ci::Pipeline.dangling_sources.each_value.first }
let(:dangling_pipeline) do
create(:ci_pipeline, source: dangling_source, project: project)
2020-10-24 23:57:45 +05:30
end
it 'returns the specified pipeline' do
2020-11-24 15:15:51 +05:30
get api("/projects/#{project.id}/pipelines/#{dangling_pipeline.id}", user)
2020-10-24 23:57:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
2020-11-24 15:15:51 +05:30
expect(json_response['sha']).to eq(dangling_pipeline.sha)
2020-10-24 23:57:45 +05:30
end
end
2019-02-15 15:39:39 +05:30
end
2019-12-04 20:38:33 +05:30
describe 'GET /projects/:id/pipelines/latest' do
context 'authorized user' do
let(:second_branch) { project.repository.branches[2] }
let!(:second_pipeline) do
create(:ci_empty_pipeline, project: project, sha: second_branch.target,
ref: second_branch.name, user: user)
end
before do
create(:ci_empty_pipeline, project: project, sha: project.commit.parent.id,
ref: project.default_branch, user: user)
end
context 'default repository branch' do
it 'gets the latest pipleine' do
get api("/projects/#{project.id}/pipelines/latest", user)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2019-12-04 20:38:33 +05:30
expect(response).to match_response_schema('public_api/v4/pipeline/detail')
expect(json_response['ref']).to eq(project.default_branch)
expect(json_response['sha']).to eq(project.commit.id)
end
end
context 'ref parameter' do
it 'gets the latest pipleine' do
get api("/projects/#{project.id}/pipelines/latest", user), params: { ref: second_branch.name }
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2019-12-04 20:38:33 +05:30
expect(response).to match_response_schema('public_api/v4/pipeline/detail')
expect(json_response['ref']).to eq(second_branch.name)
expect(json_response['sha']).to eq(second_branch.target)
end
end
end
context 'unauthorized user' do
it 'does not return a project pipeline' do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}", non_member)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2019-12-04 20:38:33 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(json_response['id']).to be nil
end
end
end
2019-07-31 22:56:46 +05:30
describe 'GET /projects/:id/pipelines/:pipeline_id/variables' do
subject { get api("/projects/#{project.id}/pipelines/#{pipeline.id}/variables", api_user) }
let(:api_user) { user }
context 'user is a mantainer' do
it 'returns pipeline variables empty' do
subject
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2019-07-31 22:56:46 +05:30
expect(json_response).to be_empty
end
context 'with variables' do
let!(:variable) { create(:ci_pipeline_variable, pipeline: pipeline, key: 'foo', value: 'bar') }
it 'returns pipeline variables' do
subject
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2019-07-31 22:56:46 +05:30
expect(json_response).to contain_exactly({ "variable_type" => "env_var", "key" => "foo", "value" => "bar" })
end
end
end
context 'user is a developer' do
let(:pipeline_owner_user) { create(:user) }
let(:pipeline) { create(:ci_empty_pipeline, project: project, user: pipeline_owner_user) }
before do
project.add_developer(api_user)
end
context 'pipeline created by the developer user' do
let(:api_user) { pipeline_owner_user }
let!(:variable) { create(:ci_pipeline_variable, pipeline: pipeline, key: 'foo', value: 'bar') }
it 'returns pipeline variables' do
subject
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2019-07-31 22:56:46 +05:30
expect(json_response).to contain_exactly({ "variable_type" => "env_var", "key" => "foo", "value" => "bar" })
end
end
context 'pipeline created is not created by the developer user' do
let(:api_user) { create(:user) }
it 'does not return pipeline variables' do
subject
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:forbidden)
2019-07-31 22:56:46 +05:30
end
end
end
context 'user is not a project member' do
it 'does not return pipeline variables' do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/variables", non_member)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2019-07-31 22:56:46 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
end
end
end
2019-02-15 15:39:39 +05:30
describe 'DELETE /projects/:id/pipelines/:pipeline_id' do
context 'authorized user' do
let(:owner) { project.owner }
it 'destroys the pipeline' do
delete api("/projects/#{project.id}/pipelines/#{pipeline.id}", owner)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:no_content)
2019-02-15 15:39:39 +05:30
expect { pipeline.reload }.to raise_error(ActiveRecord::RecordNotFound)
end
it 'returns 404 when it does not exist' do
2020-04-22 19:07:51 +05:30
delete api("/projects/#{project.id}/pipelines/#{non_existing_record_id}", owner)
2019-02-15 15:39:39 +05:30
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2019-02-15 15:39:39 +05:30
expect(json_response['message']).to eq '404 Not found'
end
2019-03-02 22:35:43 +05:30
it 'does not log an audit event' do
2020-11-24 15:15:51 +05:30
expect { delete api("/projects/#{project.id}/pipelines/#{pipeline.id}", owner) }.not_to change { AuditEvent.count }
2019-02-15 15:39:39 +05:30
end
context 'when the pipeline has jobs' do
2020-05-24 23:13:21 +05:30
let_it_be(:build) { create(:ci_build, project: project, pipeline: pipeline) }
2019-02-15 15:39:39 +05:30
it 'destroys associated jobs' do
delete api("/projects/#{project.id}/pipelines/#{pipeline.id}", owner)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:no_content)
2019-02-15 15:39:39 +05:30
expect { build.reload }.to raise_error(ActiveRecord::RecordNotFound)
end
end
end
context 'unauthorized user' do
context 'when user is not member' do
2019-07-07 11:18:12 +05:30
it 'returns a 404' do
2019-02-15 15:39:39 +05:30
delete api("/projects/#{project.id}/pipelines/#{pipeline.id}", non_member)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2019-02-15 15:39:39 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
end
end
context 'when user is developer' do
let(:developer) { create(:user) }
before do
project.add_developer(developer)
end
2019-07-07 11:18:12 +05:30
it 'returns a 403' do
2019-02-15 15:39:39 +05:30
delete api("/projects/#{project.id}/pipelines/#{pipeline.id}", developer)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:forbidden)
2019-02-15 15:39:39 +05:30
expect(json_response['message']).to eq '403 Forbidden'
end
end
end
2016-09-13 17:45:13 +05:30
end
describe 'POST /projects/:id/pipelines/:pipeline_id/retry' do
context 'authorized user' do
2020-05-24 23:13:21 +05:30
let_it_be(:pipeline) do
2016-09-13 17:45:13 +05:30
create(:ci_pipeline, project: project, sha: project.commit.id,
ref: project.default_branch)
end
2020-05-24 23:13:21 +05:30
let_it_be(:build) { create(:ci_build, :failed, pipeline: pipeline) }
2016-09-13 17:45:13 +05:30
it 'retries failed builds' do
expect do
post api("/projects/#{project.id}/pipelines/#{pipeline.id}/retry", user)
end.to change { pipeline.builds.count }.from(1).to(2)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:created)
2016-09-13 17:45:13 +05:30
expect(build.reload.retried?).to be true
end
end
context 'unauthorized user' do
2019-07-07 11:18:12 +05:30
it 'does not return a project pipeline' do
2016-09-13 17:45:13 +05:30
post api("/projects/#{project.id}/pipelines/#{pipeline.id}/retry", non_member)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:not_found)
2016-09-13 17:45:13 +05:30
expect(json_response['message']).to eq '404 Project Not Found'
expect(json_response['id']).to be nil
end
end
end
describe 'POST /projects/:id/pipelines/:pipeline_id/cancel' do
2020-05-24 23:13:21 +05:30
let_it_be(:pipeline) do
2016-09-13 17:45:13 +05:30
create(:ci_empty_pipeline, project: project, sha: project.commit.id,
ref: project.default_branch)
end
2020-05-24 23:13:21 +05:30
let_it_be(:build) { create(:ci_build, :running, pipeline: pipeline) }
2016-09-13 17:45:13 +05:30
context 'authorized user' do
2019-12-26 22:10:19 +05:30
it 'retries failed builds', :sidekiq_might_not_need_inline do
2016-09-13 17:45:13 +05:30
post api("/projects/#{project.id}/pipelines/#{pipeline.id}/cancel", user)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:ok)
2016-09-13 17:45:13 +05:30
expect(json_response['status']).to eq('canceled')
end
end
context 'user without proper access rights' do
2020-05-24 23:13:21 +05:30
let_it_be(:reporter) { create(:user) }
2016-09-13 17:45:13 +05:30
2017-09-10 17:25:29 +05:30
before do
2018-03-17 18:26:18 +05:30
project.add_reporter(reporter)
2017-09-10 17:25:29 +05:30
end
2016-09-13 17:45:13 +05:30
it 'rejects the action' do
post api("/projects/#{project.id}/pipelines/#{pipeline.id}/cancel", reporter)
2020-04-08 14:13:33 +05:30
expect(response).to have_gitlab_http_status(:forbidden)
2016-09-13 17:45:13 +05:30
expect(pipeline.reload.status).to eq('pending')
end
end
end
2020-05-24 23:13:21 +05:30
describe 'GET /projects/:id/pipelines/:pipeline_id/test_report' do
context 'authorized user' do
subject { get api("/projects/#{project.id}/pipelines/#{pipeline.id}/test_report", user) }
let(:pipeline) { create(:ci_pipeline, project: project) }
2020-10-24 23:57:45 +05:30
context 'when pipeline does not have a test report' do
it 'returns an empty test report' do
subject
2020-05-24 23:13:21 +05:30
2020-10-24 23:57:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response['total_count']).to eq(0)
2020-05-24 23:13:21 +05:30
end
2020-10-24 23:57:45 +05:30
end
2020-05-24 23:13:21 +05:30
2020-10-24 23:57:45 +05:30
context 'when pipeline has a test report' do
let(:pipeline) { create(:ci_pipeline, :with_test_reports, project: project) }
2020-05-24 23:13:21 +05:30
2020-10-24 23:57:45 +05:30
it 'returns the test report' do
subject
2020-05-24 23:13:21 +05:30
2020-10-24 23:57:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response['total_count']).to eq(4)
2020-05-24 23:13:21 +05:30
end
end
2020-10-24 23:57:45 +05:30
context 'when pipeline has corrupt test reports' do
2020-05-24 23:13:21 +05:30
before do
2020-10-24 23:57:45 +05:30
create(:ci_build, :broken_test_reports, name: 'rspec', pipeline: pipeline)
2020-05-24 23:13:21 +05:30
end
2020-10-24 23:57:45 +05:30
it 'returns a suite_error' do
2020-05-24 23:13:21 +05:30
subject
2020-10-24 23:57:45 +05:30
expect(response).to have_gitlab_http_status(:ok)
expect(json_response['test_suites'].first['suite_error']).to eq('JUnit XML parsing failed: 1:1: FATAL: Document is empty')
2020-05-24 23:13:21 +05:30
end
end
end
context 'unauthorized user' do
it 'does not return project pipelines' do
get api("/projects/#{project.id}/pipelines/#{pipeline.id}/test_report", non_member)
expect(response).to have_gitlab_http_status(:not_found)
expect(json_response['message']).to eq '404 Project Not Found'
end
end
end
2016-09-13 17:45:13 +05:30
end