Removes specs from jobs

* adds some authorization that is needed since setup is different
* adds helper and shared_example

lib/api/pipelines.rb

@@ -14,6 +14,26 @@ module API
         detail 'This feature was introduced in GitLab 8.11.'
         success Entities::PipelineBasic
       end
+
+      helpers do
+        params :optional_scope do
+          optional :scope, types: [String, Array[String]], desc: 'The scope of builds to show',
+                           values: ::CommitStatus::AVAILABLE_STATUSES,
+                           coerce_with: ->(scope) {
+                             case scope
+                             when String
+                               [scope]
+                             when ::Hash
+                               scope.values
+                             when ::Array
+                               scope
+                             else
+                               ['unknown']
+                             end
+                           }
+        end
+      end
+
       params do
         use :pagination
         optional :scope,    type: String, values: %w[running pending finished branches tags],
@@ -103,10 +123,12 @@ module API
         use :optional_scope
         use :pagination
       end
+
       # rubocop: disable CodeReuse/ActiveRecord
       get ':id/pipelines/:pipeline_id/jobs' do
+        authenticate!
         authorize!(:read_pipeline, user_project)
-        pipeline = user_project.ci_pipelines.find(params[:pipeline_id])
+        pipeline = user_project.all_pipelines.find(params[:pipeline_id])
         authorize!(:read_build, pipeline)
 
         builds = pipeline.builds
@@ -129,8 +151,9 @@ module API
 
       # rubocop: disable CodeReuse/ActiveRecord
       get ':id/pipelines/:pipeline_id/bridges' do
+        authenticate!
         authorize!(:read_build, user_project)
-        pipeline = user_project.ci_pipelines.find(params[:pipeline_id])
+        pipeline = user_project.all_pipelines.find(params[:pipeline_id])
         authorize!(:read_pipeline, pipeline)
 
         bridges = pipeline.bridges
@@ -221,6 +244,19 @@ module API
     end
 
     helpers do
+      # rubocop: disable CodeReuse/ActiveRecord
+      def filter_builds(builds, scope)
+        return builds if scope.nil? || scope.empty?
+
+        available_statuses = ::CommitStatus::AVAILABLE_STATUSES
+
+        unknown = scope - available_statuses
+        render_api_error!('Scope contains invalid value(s)', 400) unless unknown.empty?
+
+        builds.where(status: available_statuses && scope)
+      end
+
+      # rubocop: enable CodeReuse/ActiveRecord
       def pipeline
         strong_memoize(:pipeline) do
           user_project.ci_pipelines.find(params[:pipeline_id])

spec/requests/api/ci/pipelines_spec.rb

@@ -20,6 +20,32 @@ RSpec.describe API::Ci::Pipelines do
     project.add_maintainer(user)
   end
 
+  shared_examples 'a job with artifacts and trace' do |result_is_array: true|
+    context 'with artifacts and trace' do
+      let!(:second_job) { create(:ci_build, :trace_artifact, :artifacts, :test_reports, pipeline: pipeline) }
+
+      it 'returns artifacts and trace data', :skip_before_request do
+        get api(api_endpoint, api_user)
+        json_job = result_is_array ? json_response.select { |job| job['id'] == second_job.id }.first : json_response
+
+        expect(json_job['artifacts_file']).not_to be_nil
+        expect(json_job['artifacts_file']).not_to be_empty
+        expect(json_job['artifacts_file']['filename']).to eq(second_job.artifacts_file.filename)
+        expect(json_job['artifacts_file']['size']).to eq(second_job.artifacts_file.size)
+        expect(json_job['artifacts']).not_to be_nil
+        expect(json_job['artifacts']).to be_an Array
+        expect(json_job['artifacts'].size).to eq(second_job.job_artifacts.length)
+        json_job['artifacts'].each do |artifact|
+          expect(artifact).not_to be_nil
+          file_type = Ci::JobArtifact.file_types[artifact['file_type']]
+          expect(artifact['size']).to eq(second_job.job_artifacts.find_by(file_type: file_type).size)
+          expect(artifact['filename']).to eq(second_job.job_artifacts.find_by(file_type: file_type).filename)
+          expect(artifact['file_format']).to eq(second_job.job_artifacts.find_by(file_type: file_type).file_format)
+        end
+      end
+    end
+  end
+
   describe 'GET /projects/:id/pipelines ' do
     it_behaves_like 'pipelines visibility table'
 
@@ -307,6 +333,292 @@ RSpec.describe API::Ci::Pipelines do
     end
   end
 
+  describe 'GET /projects/:id/pipelines/:pipeline_id/jobs' do
+    let(:query) { {} }
+    let(:api_user) { user }
+    let!(: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]
+        job
+        get api("/projects/#{project.id}/pipelines/#{pipeline.id}/jobs", api_user), params: query
+      end
+    end
+
+    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
+      end
+
+      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
+      end
+
+      it_behaves_like 'a job with artifacts and trace' do
+        let(:api_endpoint) { "/projects/#{project.id}/pipelines/#{pipeline.id}/jobs" }
+      end
+
+      it 'returns pipeline data' do
+        json_job = json_response.first
+
+        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
+      end
+
+      context 'filter jobs with one scope element' do
+        let(:query) { { 'scope' => 'pending' } }
+
+        it do
+          expect(response).to have_gitlab_http_status(:ok)
+          expect(json_response).to be_an Array
+        end
+      end
+
+      context 'filter jobs with array of scope elements' do
+        let(:query) { { scope: %w(pending running) } }
+
+        it do
+          expect(response).to have_gitlab_http_status(:ok)
+          expect(json_response).to be_an Array
+        end
+      end
+
+      context 'respond 400 when scope contains invalid state' do
+        let(:query) { { scope: %w(unknown running) } }
+
+        it { expect(response).to have_gitlab_http_status(:bad_request) }
+      end
+
+      context 'jobs in different pipelines' do
+        let!(:pipeline2) { create(:ci_empty_pipeline, project: project) }
+        let!(:job2) { create(:ci_build, pipeline: pipeline2) }
+
+        it 'excludes jobs from other pipelines' do
+          json_response.each { |job| expect(job['pipeline']['id']).to eq(pipeline.id) }
+        end
+      end
+
+      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
+
+        create_list(:ci_build, 3, :trace_artifact, :artifacts, :test_reports, pipeline: pipeline)
+
+        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
+
+    context 'unauthorized user' do
+      context 'when user is not logged in' do
+        let(:api_user) { nil }
+
+        it 'does not return jobs' do
+          expect(response).to have_gitlab_http_status(:unauthorized)
+        end
+      end
+
+      context 'when user is guest' do
+        let(:guest) { create(:project_member, :guest, project: project).user }
+        let(:api_user) { guest }
+
+        it 'does not return jobs' do
+          expect(response).to have_gitlab_http_status(:forbidden)
+        end
+      end
+    end
+  end
+
+  describe 'GET /projects/:id/pipelines/:pipeline_id/bridges' do
+    let!(: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]
+        get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
+      end
+    end
+
+    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
+      end
+
+      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
+
+      it 'returns pipeline data' do
+        json_bridge = json_response.first
+
+        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
+
+      it 'returns downstream pipeline data' do
+        json_bridge = json_response.first
+
+        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
+
+      context 'filter bridges' do
+        before do
+          create_bridge(pipeline, :pending)
+          create_bridge(pipeline, :running)
+        end
+
+        context 'with one scope element' do
+          let(:query) { { 'scope' => 'pending' } }
+
+          it :skip_before_request do
+            get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
+
+            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"
+          end
+        end
+
+        context 'with array of scope elements' do
+          let(:query) { { scope: %w(pending running) } }
+
+          it :skip_before_request do
+            get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
+
+            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 }
+          end
+        end
+      end
+
+      context 'respond 400 when scope contains invalid state' do
+        let(:query) { { scope: %w(unknown running) } }
+
+        it { expect(response).to have_gitlab_http_status(:bad_request) }
+      end
+
+      context 'bridges in different pipelines' do
+        let!(:pipeline2) { create(:ci_empty_pipeline, project: project) }
+        let!(:bridge2) { create(:ci_bridge, pipeline: pipeline2) }
+
+        it 'excludes bridges from other pipelines' do
+          json_response.each { |bridge| expect(bridge['pipeline']['id']).to eq(pipeline.id) }
+        end
+      end
+
+      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
+
+        3.times { create_bridge(pipeline) }
+
+        expect do
+          get api("/projects/#{project.id}/pipelines/#{pipeline.id}/bridges", api_user), params: query
+        end.not_to exceed_all_query_limit(control_count)
+      end
+    end
+
+    context 'unauthorized user' do
+      context 'when user is not logged in' do
+        let(:api_user) { nil }
+
+        it 'does not return bridges' do
+          expect(response).to have_gitlab_http_status(:unauthorized)
+        end
+      end
+
+      context 'when user is guest' do
+        let(:api_user) { guest }
+        let(:guest) { create(:project_member, :guest, project: project).user }
+
+        it 'does not return bridges' do
+          expect(response).to have_gitlab_http_status(:forbidden)
+        end
+      end
+
+      context 'when user has no read access for pipeline' do
+        before do
+          allow(Ability).to receive(:allowed?).and_call_original
+          allow(Ability).to receive(:allowed?).with(api_user, :read_pipeline, pipeline).and_return(false)
+        end
+
+        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)
+        end
+      end
+
+      context 'when user has no read_build access for project' do
+        before do
+          allow(Ability).to receive(:allowed?).and_call_original
+          allow(Ability).to receive(:allowed?).with(api_user, :read_build, project).and_return(false)
+        end
+
+        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)
+        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
+
   describe 'POST /projects/:id/pipeline ' do
     def expect_variables(variables, expected_variables)
       variables.each_with_index do |variable, index|