Add latest changes from gitlab-org/gitlab@master

spec/services/projects/prometheus/alerts/create_events_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Projects::Prometheus::Alerts::CreateEventsService do
+  let(:user) { create(:user) }
+  let_it_be(:project) { create(:project) }
+  let(:metric) { create(:prometheus_metric, project: project) }
+  let(:service) { described_class.new(project, user, alerts_payload) }
+
+  shared_examples 'events persisted' do |expected_count|
+    subject { service.execute }
+
+    it 'returns proper amount of created events' do
+      expect(subject.size).to eq(expected_count)
+    end
+
+    it 'increments event count' do
+      expect { subject }.to change { PrometheusAlertEvent.count }.to(expected_count)
+    end
+  end
+
+  shared_examples 'no events persisted' do
+    subject { service.execute }
+
+    it 'returns no created events' do
+      expect(subject).to be_empty
+    end
+
+    it 'does not change event count' do
+      expect { subject }.not_to change { PrometheusAlertEvent.count }
+    end
+  end
+
+  shared_examples 'self managed events persisted' do
+    subject { service.execute }
+
+    it 'returns created events' do
+      expect(subject).not_to be_empty
+    end
+
+    it 'does change self managed event count' do
+      expect { subject }.to change { SelfManagedPrometheusAlertEvent.count }
+    end
+  end
+
+  context 'with valid alerts_payload' do
+    let!(:alert) { create(:prometheus_alert, prometheus_metric: metric, project: project) }
+
+    let(:events) { service.execute }
+
+    context 'with a firing payload' do
+      let(:started_at) { truncate_to_second(Time.now) }
+      let(:firing_event) { alert_payload(status: 'firing', started_at: started_at) }
+      let(:alerts_payload) { { 'alerts' => [firing_event] } }
+
+      it_behaves_like 'events persisted', 1
+
+      it 'returns created event' do
+        event = events.first
+
+        expect(event).to be_firing
+        expect(event.started_at).to eq(started_at)
+        expect(event.ended_at).to be_nil
+      end
+
+      context 'with 2 different firing events' do
+        let(:another_firing_event) { alert_payload(status: 'firing', started_at: started_at + 1) }
+        let(:alerts_payload) { { 'alerts' => [firing_event, another_firing_event] } }
+
+        it_behaves_like 'events persisted', 2
+      end
+
+      context 'with already persisted firing event' do
+        before do
+          service.execute
+        end
+
+        it_behaves_like 'no events persisted'
+      end
+
+      context 'with duplicate payload' do
+        let(:alerts_payload) { { 'alerts' => [firing_event, firing_event] } }
+
+        it_behaves_like 'events persisted', 1
+      end
+    end
+
+    context 'with a resolved payload' do
+      let(:started_at) { truncate_to_second(Time.now) }
+      let(:ended_at) { started_at + 1 }
+      let(:payload_key) { PrometheusAlertEvent.payload_key_for(alert.prometheus_metric_id, utc_rfc3339(started_at)) }
+      let(:resolved_event) { alert_payload(status: 'resolved', started_at: started_at, ended_at: ended_at) }
+      let(:alerts_payload) { { 'alerts' => [resolved_event] } }
+
+      context 'with a matching firing event' do
+        before do
+          create(:prometheus_alert_event,
+                 prometheus_alert: alert,
+                 payload_key: payload_key,
+                 started_at: started_at)
+        end
+
+        it 'does not create an additional event' do
+          expect { service.execute }.not_to change { PrometheusAlertEvent.count }
+        end
+
+        it 'marks firing event as `resolved`' do
+          expect(events.size).to eq(1)
+
+          event = events.first
+          expect(event).to be_resolved
+          expect(event.started_at).to eq(started_at)
+          expect(event.ended_at).to eq(ended_at)
+        end
+
+        context 'with duplicate payload' do
+          let(:alerts_payload) { { 'alerts' => [resolved_event, resolved_event] } }
+
+          it 'does not create an additional event' do
+            expect { service.execute }.not_to change { PrometheusAlertEvent.count }
+          end
+
+          it 'marks firing event as `resolved` only once' do
+            expect(events.size).to eq(1)
+          end
+        end
+      end
+
+      context 'without a matching firing event' do
+        context 'due to payload_key' do
+          let(:payload_key) { 'some other payload_key' }
+
+          before do
+            create(:prometheus_alert_event,
+                   prometheus_alert: alert,
+                   payload_key: payload_key,
+                   started_at: started_at)
+          end
+
+          it_behaves_like 'no events persisted'
+        end
+
+        context 'due to status' do
+          before do
+            create(:prometheus_alert_event, :resolved,
+                   prometheus_alert: alert,
+                   started_at: started_at)
+          end
+
+          it_behaves_like 'no events persisted'
+        end
+      end
+
+      context 'with already resolved event' do
+        before do
+          service.execute
+        end
+
+        it_behaves_like 'no events persisted'
+      end
+    end
+
+    context 'with a metric from another project' do
+      let(:another_project) { create(:project) }
+      let(:metric) { create(:prometheus_metric, project: another_project) }
+      let(:alerts_payload) { { 'alerts' => [alert_payload] } }
+
+      let!(:alert) do
+        create(:prometheus_alert,
+               prometheus_metric: metric,
+               project: another_project)
+      end
+
+      it_behaves_like 'no events persisted'
+    end
+  end
+
+  context 'with invalid payload' do
+    let(:alert) { create(:prometheus_alert, prometheus_metric: metric, project: project) }
+
+    describe '`alerts` key' do
+      context 'is missing' do
+        let(:alerts_payload) { {} }
+
+        it_behaves_like 'no events persisted'
+      end
+
+      context 'is nil' do
+        let(:alerts_payload) { { 'alerts' => nil } }
+
+        it_behaves_like 'no events persisted'
+      end
+
+      context 'is empty' do
+        let(:alerts_payload) { { 'alerts' => [] } }
+
+        it_behaves_like 'no events persisted'
+      end
+
+      context 'is not a Hash' do
+        let(:alerts_payload) { { 'alerts' => [:not_a_hash] } }
+
+        it_behaves_like 'no events persisted'
+      end
+
+      describe '`status`' do
+        context 'is missing' do
+          let(:alerts_payload) { { 'alerts' => [alert_payload(status: nil)] } }
+
+          it_behaves_like 'no events persisted'
+        end
+
+        context 'is invalid' do
+          let(:alerts_payload) { { 'alerts' => [alert_payload(status: 'invalid')] } }
+
+          it_behaves_like 'no events persisted'
+        end
+      end
+
+      describe '`started_at`' do
+        context 'is missing' do
+          let(:alerts_payload) { { 'alerts' => [alert_payload(started_at: nil)] } }
+
+          it_behaves_like 'no events persisted'
+        end
+
+        context 'is invalid' do
+          let(:alerts_payload) { { 'alerts' => [alert_payload(started_at: 'invalid date')] } }
+
+          it_behaves_like 'no events persisted'
+        end
+      end
+
+      describe '`ended_at`' do
+        context 'is missing and status is resolved' do
+          let(:alerts_payload) { { 'alerts' => [alert_payload(ended_at: nil, status: 'resolved')] } }
+
+          it_behaves_like 'no events persisted'
+        end
+
+        context 'is invalid and status is resolved' do
+          let(:alerts_payload) { { 'alerts' => [alert_payload(ended_at: 'invalid date', status: 'resolved')] } }
+
+          it_behaves_like 'no events persisted'
+        end
+      end
+
+      describe '`labels`' do
+        describe '`gitlab_alert_id`' do
+          context 'is missing' do
+            let(:alerts_payload) { { 'alerts' => [alert_payload(gitlab_alert_id: nil)] } }
+
+            it_behaves_like 'no events persisted'
+          end
+
+          context 'is missing but title is given' do
+            let(:alerts_payload) { { 'alerts' => [alert_payload(gitlab_alert_id: nil, title: 'alert')] } }
+
+            it_behaves_like 'self managed events persisted'
+          end
+
+          context 'is missing and environment name is given' do
+            let(:environment) { create(:environment, project: project) }
+            let(:alerts_payload) { { 'alerts' => [alert_payload(gitlab_alert_id: nil, title: 'alert', environment: environment.name)] } }
+
+            it_behaves_like 'self managed events persisted'
+
+            it 'associates the environment to the alert event' do
+              service.execute
+
+              expect(SelfManagedPrometheusAlertEvent.last.environment).to eq environment
+            end
+          end
+
+          context 'is invalid' do
+            let(:alerts_payload) { { 'alerts' => [alert_payload(gitlab_alert_id: '-1')] } }
+
+            it_behaves_like 'no events persisted'
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def alert_payload(status: 'firing', started_at: Time.now, ended_at: Time.now, gitlab_alert_id: alert.prometheus_metric_id, title: nil, environment: nil)
+    payload = {}
+
+    payload['status'] = status if status
+    payload['startsAt'] = utc_rfc3339(started_at) if started_at
+    payload['endsAt'] = utc_rfc3339(ended_at) if ended_at
+    payload['labels'] = {}
+    payload['labels']['gitlab_alert_id'] = gitlab_alert_id.to_s if gitlab_alert_id
+    payload['labels']['alertname'] = title if title
+    payload['labels']['gitlab_environment_name'] = environment if environment
+
+    payload
+  end
+
+  # Example: 2018-09-27T18:25:31.079079416Z
+  def utc_rfc3339(date)
+    date.utc.rfc3339
+  rescue
+    date
+  end
+
+  def truncate_to_second(date)
+    date.change(usec: 0)
+  end
+end

spec/services/snippets/create_service_spec.rb

@@ -193,6 +193,12 @@ describe Snippets::CreateService do
           subject
         end
+        it 'destroys the snippet_repository' do
+          subject
+
+          expect(SnippetRepository.count).to be_zero
+        end
+
         it 'returns the error' do
           response = subject

spec/support/shared_examples/requests/api/notes_shared_examples.rb

@@ -172,6 +172,8 @@ RSpec.shared_examples 'noteable API' do |parent_type, noteable_type, id_name|
       if parent_type == 'projects'
         context 'by a project owner' do
+          let(:user) { project.owner }
+
           it 'sets the creation time on the new note' do
             post api("/#{parent_type}/#{parent.id}/#{noteable_type}/#{noteable[id_name]}/notes", user), params: params

spec/tasks/gitlab/cleanup_rake_spec.rb

@@ -120,6 +120,71 @@ describe 'gitlab:cleanup rake tasks' do
     end
   end
+  describe 'gitlab:cleanup:orphan_lfs_file_references' do
+    subject(:rake_task) { run_rake_task('gitlab:cleanup:orphan_lfs_file_references') }
+
+    let(:project) { create(:project, :repository) }
+
+    before do
+      stub_env('PROJECT_ID', project.id)
+    end
+
+    it 'runs the task without errors' do
+      expect(Gitlab::Cleanup::OrphanLfsFileReferences)
+        .to receive(:new).and_call_original
+
+      expect { rake_task }.not_to raise_error
+    end
+
+    context 'with DRY_RUN set to false' do
+      before do
+        stub_env('DRY_RUN', 'false')
+      end
+
+      it 'passes dry_run correctly' do
+        expect(Gitlab::Cleanup::OrphanLfsFileReferences)
+          .to receive(:new)
+          .with(project,
+                limit: anything,
+                dry_run: false,
+                logger: anything)
+          .and_call_original
+
+        rake_task
+      end
+    end
+
+    context 'with LIMIT set to 100' do
+      before do
+        stub_env('LIMIT', '100')
+      end
+
+      it 'passes limit as integer' do
+        expect(Gitlab::Cleanup::OrphanLfsFileReferences)
+          .to receive(:new)
+          .with(project,
+                limit: 100,
+                dry_run: true,
+                logger: anything)
+          .and_call_original
+
+        rake_task
+      end
+    end
+  end
+
+  describe 'gitlab:cleanup:orphan_lfs_files' do
+    subject(:rake_task) { run_rake_task('gitlab:cleanup:orphan_lfs_files') }
+
+    it 'runs RemoveUnreferencedLfsObjectsWorker' do
+      expect_any_instance_of(RemoveUnreferencedLfsObjectsWorker)
+        .to receive(:perform)
+        .and_call_original
+
+      rake_task
+    end
+  end
+
   context 'sessions' do
     describe 'gitlab:cleanup:sessions:active_sessions_lookup_keys', :clean_gitlab_redis_shared_state do
       subject(:rake_task) { run_rake_task('gitlab:cleanup:sessions:active_sessions_lookup_keys') }

spec/views/projects/artifacts/_artifact.html.haml_spec.rb

@@ -38,7 +38,7 @@ RSpec.describe "projects/artifacts/_artifact.html.haml" do
       let(:user) { create(:user) }
       it 'has a delete button' do
-        allow_any_instance_of(ProjectTeam).to receive(:max_member_access).and_return(Gitlab::Access::MASTER)
+        allow_any_instance_of(ProjectTeam).to receive(:max_member_access).and_return(Gitlab::Access::MAINTAINER)
         render_partial
         expect(rendered).to have_link('Delete artifacts', href: project_artifact_path(project, project.job_artifacts.first))

spec/workers/incident_management/process_prometheus_alert_worker_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe IncidentManagement::ProcessPrometheusAlertWorker do
+  describe '#perform' do
+    let_it_be(:project) { create(:project) }
+    let_it_be(:prometheus_alert) { create(:prometheus_alert, project: project) }
+    let_it_be(:payload_key) { PrometheusAlertEvent.payload_key_for(prometheus_alert.prometheus_metric_id, prometheus_alert.created_at.rfc3339) }
+    let!(:prometheus_alert_event) { create(:prometheus_alert_event, prometheus_alert: prometheus_alert, payload_key: payload_key) }
+
+    let(:alert_params) do
+      {
+        startsAt: prometheus_alert.created_at.rfc3339,
+        labels: {
+          gitlab_alert_id: prometheus_alert.prometheus_metric_id
+        }
+      }.with_indifferent_access
+    end
+
+    it 'creates an issue' do
+      expect { subject.perform(project.id, alert_params) }
+        .to change(Issue, :count)
+        .by(1)
+    end
+
+    it 'relates issue to an event' do
+      expect { subject.perform(project.id, alert_params) }
+        .to change(prometheus_alert.related_issues, :count)
+        .from(0)
+        .to(1)
+    end
+
+    context 'resolved event' do
+      let(:issue) { create(:issue, project: project) }
+
+      before do
+        prometheus_alert_event.related_issues << issue
+        prometheus_alert_event.resolve
+      end
+
+      it 'does not create an issue' do
+        expect { subject.perform(project.id, alert_params) }
+          .not_to change(Issue, :count)
+      end
+
+      it 'closes the existing issue' do
+        expect { subject.perform(project.id, alert_params) }
+          .to change { issue.reload.state }
+          .from('opened')
+          .to('closed')
+      end
+
+      it 'leaves a system note on the issue' do
+        expect(SystemNoteService)
+          .to receive(:auto_resolve_prometheus_alert)
+
+        subject.perform(project.id, alert_params)
+      end
+    end
+
+    context 'when project could not be found' do
+      let(:non_existing_project_id) { (Project.maximum(:id) || 0) + 1 }
+
+      it 'does not create an issue' do
+        expect { subject.perform(non_existing_project_id, alert_params) }
+          .not_to change(Issue, :count)
+      end
+
+      it 'does not relate issue to an event' do
+        expect { subject.perform(non_existing_project_id, alert_params) }
+          .not_to change(prometheus_alert.related_issues, :count)
+      end
+    end
+
+    context 'when event could not be found' do
+      before do
+        alert_params[:labels][:gitlab_alert_id] = (PrometheusAlertEvent.maximum(:id) || 0) + 1
+      end
+
+      it 'does not create an issue' do
+        expect { subject.perform(project.id, alert_params) }
+          .not_to change(Issue, :count)
+      end
+
+      it 'does not relate issue to an event' do
+        expect { subject.perform(project.id, alert_params) }
+          .not_to change(prometheus_alert.related_issues, :count)
+      end
+    end
+
+    context 'when issue could not be created' do
+      before do
+        allow_next_instance_of(IncidentManagement::CreateIssueService) do |instance|
+          allow(instance).to receive(:execute).and_return( { error: true } )
+        end
+      end
+
+      it 'does not relate issue to an event' do
+        expect { subject.perform(project.id, alert_params) }
+          .not_to change(prometheus_alert.related_issues, :count)
+      end
+    end
+
+    context 'self-managed alert' do
+      let(:alert_name) { 'alert' }
+      let(:starts_at) { Time.now.rfc3339 }
+
+      let!(:prometheus_alert_event) do
+        payload_key = SelfManagedPrometheusAlertEvent.payload_key_for(starts_at, alert_name, 'vector(1)')
+        create(:self_managed_prometheus_alert_event, project: project, payload_key: payload_key)
+      end
+
+      let(:alert_params) do
+        {
+          startsAt: starts_at,
+          generatorURL: 'http://localhost:9090/graph?g0.expr=vector%281%29&g0.tab=1',
+          labels: {
+            alertname: alert_name
+          }
+        }.with_indifferent_access
+      end
+
+      it 'creates an issue' do
+        expect { subject.perform(project.id, alert_params) }
+          .to change(Issue, :count)
+          .by(1)
+      end
+
+      it 'relates issue to an event' do
+        expect { subject.perform(project.id, alert_params) }
+          .to change(prometheus_alert_event.related_issues, :count)
+          .from(0)
+          .to(1)
+      end
+
+      context 'when event could not be found' do
+        before do
+          alert_params[:generatorURL] = 'http://somethingelse.com'
+        end
+
+        it 'creates an issue' do
+          expect { subject.perform(project.id, alert_params) }
+            .to change(Issue, :count)
+            .by(1)
+        end
+
+        it 'does not relate issue to an event' do
+          expect { subject.perform(project.id, alert_params) }
+            .not_to change(prometheus_alert.related_issues, :count)
+        end
+      end
+    end
+  end
+end