gitlab_quality-test_tooling 2.9.0 → 2.11.0

data/lib/gitlab_quality/test_tooling/feature_readiness/concerns/issue_concern.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      module Concerns
+        module IssueConcern
+          OPERATIONAL_READINESS_CHECKLIST_LABEL = 'operational-readiness-checklist'
+
+          def create_operation_readiness_issue(work_item_title, assignee_id, issue_client, repository_files_client)
+            operational_readiness_issue = issue_client.create_issue(
+              title: "Operational Readiness Checklist for: '#{work_item_title}'",
+              description: repository_files_client.file_contents,
+              labels: [OPERATIONAL_READINESS_CHECKLIST_LABEL],
+              assignee_id: assignee_id
+            )
+
+            puts "\nCreated operational readiness issue: #{operational_readiness_issue.web_url}\n"
+
+            operational_readiness_issue
+          end
+
+          def has_operational_readiness_issue_linked?(linked_issue_iids, issue_client)
+            linked_issues(linked_issue_iids, issue_client).any? { |issue| (issue.labels & [OPERATIONAL_READINESS_CHECKLIST_LABEL]).any? }
+          end
+
+          def linked_issues(linked_issue_iids, issue_client)
+            linked_issue_iids.flat_map { |iid| issue_client.find_issues(iid: iid) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/concerns/work_item_concern.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      module Concerns
+        module WorkItemConcern
+          OPERATIONAL_READINESS_NOTE_ID = '<!-- OPERATIONAL READINESS PRECHECK COMMENT -->'
+          OPERATIONAL_READINESS_TRACKING_LABEL = 'tracking operational readiness'
+
+          def add_operational_readiness_precheck_comment(work_item, work_items_client, label_client)
+            comment = <<~COMMENT
+              #{OPERATIONAL_READINESS_NOTE_ID}
+              ## Operational Readiness Pre-Check
+
+              @#{work_item[:author][:username]} This is an automated comment to help determine if an
+              [operational readiness check](https://gitlab.com/gitlab-org/gitlab/-/blob/master/.gitlab/issue_templates/Operational%20Readiness.md?ref_type=heads)
+              is needed for this feature.
+
+              Please respond with the ✅ emoji on this comment if your feature meets any of the below criteria. If not, please respond with the ❌ emoji.
+
+              1. Requires new infrastructure components, or significant changes to existing components that have dependencies on the GitLab application.
+              2. Requires changes to our application architecture that change how the infrastructure scales, GitLab is deployed or how data is processed or stored.
+              3. Adds new services or changes existing services that will factor into the availability of the GitLab application.
+            COMMENT
+
+            add_labels(ids_for_labels([OPERATIONAL_READINESS_TRACKING_LABEL], label_client), work_item[:id], work_items_client)
+
+            discussion = existing_note_containing_text(OPERATIONAL_READINESS_NOTE_ID, work_item[:iid], work_items_client)
+
+            return discussion if discussion
+
+            work_items_client.create_discussion(id: work_item[:id], note: comment)
+
+            puts "\nAdded operational readiness comment to epic work item: #{work_item[:webUrl]}\n"
+
+            existing_note_containing_text(OPERATIONAL_READINESS_NOTE_ID, work_item[:iid], work_items_client)
+          end
+
+          def existing_note_containing_text(text, work_item_iid, client)
+            work_item = fetch_work_item(work_item_iid, client, [:notes])
+
+            work_item[:widgets]
+              .find { |widget| widget.key?(:discussions) }
+              .dig(:discussions, :nodes)
+              .find { |node| node[:notes][:nodes].any? { |node| node[:body].include?(text) } }
+              &.dig(:notes, :nodes, 0)
+          end
+
+          def link_operation_readiness_issue(issue, work_item, link_type, client)
+            client.create_linked_items(work_item_id: work_item[:id], item_ids: ["gid://gitlab/Issue/#{issue.id}"], link_type: link_type)
+          end
+
+          def note_has_emoji?(note, emoji_name)
+            note&.dig(:awardEmoji, :nodes)&.any? { |node| node[:name] == emoji_name }
+          end
+
+          def post_comment_about_operation_readiness_issue_created(work_item, issue, precheck_comment, client)
+            comment_text = <<~COMMENT
+              @#{work_item[:author][:username]} Thanks for confirming that your feature requires an operational readiness check.
+              Based on your response, an operational readiness check issue has been created and linked to this issue: #{issue.web_url}.
+            COMMENT
+
+            client.create_discussion_note(work_item_id: work_item[:id], discussion_id: precheck_comment.dig(:discussion, :id), text: comment_text)
+          end
+
+          def get_labels(work_item)
+            labels_node = work_item[:widgets]&.find { |widget| widget.key?(:labels) }
+            labels_node && labels_node[:labels][:nodes].map { |label| label[:title] }
+          end
+
+          def get_issue_iids(work_item, project)
+            childern_node = work_item[:widgets]&.find { |widget| widget.key?(:children) }
+            childern_node && childern_node[:children][:nodes].filter_map { |issue| issue[:iid] if issue[:workItemType][:name] == "Issue" && issue[:project][:fullPath] == project }
+          end
+
+          def has_label?(work_item, label)
+            get_labels(work_item).include?(label)
+          end
+
+          def add_labels(label_ids, work_item_id, client)
+            client.add_labels(work_item_id: work_item_id, label_ids: label_gids(label_ids))
+          end
+
+          def fetch_work_item(iid, client, widgets = [])
+            client.work_item(workitem_iid: iid, widgets: widgets)
+          end
+
+          def has_a_child_epic?(epic)
+            epic[:widgets]
+              .find { |widget| widget.has_key?(:children) }[:children][:nodes]
+              .any? { |child| child[:workItemType][:name] == "Epic" }
+          end
+
+          def work_item_author_id(work_item)
+            extract_id_from_gid(work_item[:author][:id])
+          end
+
+          def linked_issue_iids(work_item)
+            work_item[:widgets].find { |widget| widget.key?(:linkedItems) }
+                               .dig(:linkedItems, :nodes)
+                               .map { |node| node.dig(:workItem, :iid) }
+          end
+
+          def label_gids(label_ids = [])
+            label_ids.map { |label_id| "gid://gitlab/Label/#{label_id}" }
+          end
+
+          def ids_for_labels(labels, label_client)
+            labels.map { |label| get_id_for_label(label, label_client) }
+          end
+
+          def get_id_for_label(label_name, label_client)
+            labels = label_client.labels(options: { search: label_name })
+
+            raise "No labels found with name: '#{label_name}'" if labels.empty?
+
+            labels.first.id
+          end
+
+          def extract_id_from_gid(gid)
+            gid.to_s.split('/').last.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/evaluation.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      class Evaluation
+        include Concerns::IssueConcern
+        include Concerns::WorkItemConcern
+
+        BASE_LABELS_FOR_SEARCH = ['feature::addition'].freeze
+        FEATURE_READINESS_TRACKING_LABEL = 'tracking feature readiness'
+
+        def initialize(token:, project: nil, group: nil, limit_to_minutes: nil, epic_iid: nil, search_labels: [], dry_run: false)
+          @token = token
+          @project = "#{group}/#{project}"
+          @group = group
+          @limit_to_minutes = limit_to_minutes
+          @epic_iid = epic_iid
+          @search_labels = search_labels
+          @dry_run = dry_run
+          @analyzed_epics = []
+        end
+
+        def invoke!
+          created_after = utc_time_minus_mins(limit_to_minutes)
+
+          epics = fetch_epics(created_after)
+
+          epics.compact.each do |epic|
+            @analyzed_epics << process_epic(epic)
+          rescue StandardError => e
+            puts "ERROR processing epic #{epic[:epic_web_url]} due to: #{e}"
+          end
+
+          report_epics(analyzed_epics)
+        end
+
+        private
+
+        attr_reader :token, :project, :dry_run, :group, :limit_to_minutes, :epic_iid, :search_labels, :analyzed_epics
+
+        def work_items_client
+          @work_items_client ||= (dry_run ? GitlabClient::WorkItemsDryClient : GitlabClient::WorkItemsClient).new(token: token, project: project, group: group)
+        end
+
+        def fetch_epics(created_after)
+          return [fetch_work_item(epic_iid, work_items_client, [:hierarchy, :labels])] if epic_iid
+
+          work_items_client.paginated_call(:group_work_items,
+            labels: search_labels.concat(BASE_LABELS_FOR_SEARCH).uniq, state: 'opened', created_after: created_after)
+        end
+
+        def label_client
+          @label_client ||= GitlabClient::LabelsClient.new(token: token, project: project)
+        end
+
+        def process_epic(epic)
+          epic = fetch_work_item(epic[:iid], work_items_client, [:hierarchy, :labels])
+
+          AnalyzedItems::AnalyzedEpic.new(epic: epic, token: token, project: project, group: group, dry_run: dry_run)
+                                     .tap(&:analyze).result
+        end
+
+        def utc_time_minus_mins(mins)
+          (Time.now - (mins * 60)).utc.iso8601 if mins
+        end
+
+        def report_epics(epics)
+          epics.each do |epic|
+            add_labels(ids_for_labels([FEATURE_READINESS_TRACKING_LABEL], label_client), epic[:epic_id], work_items_client)
+
+            Report::FeatureReadiness::ReportOnEpic.report(epic, work_items_client)
+          rescue StandardError => e
+            puts "ERROR reporting epic #{epic[:epic_web_url]} due to: #{e}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/operational_readiness_check.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      class OperationalReadinessCheck
+        include Concerns::IssueConcern
+        include Concerns::WorkItemConcern
+
+        BASE_LABELS_FOR_SEARCH = ["feature::addition"].freeze
+        OPERATIONAL_READINESS_ISSUE_TEMPLATE_PATH = '.gitlab/issue_templates/Operational Readiness.md'
+
+        def initialize(token:, project: nil, group: nil, limit_to_minutes: nil, search_labels: [], issue_is_blocking: false, dry_run: false)
+          @token = token
+          @project = "#{group}/#{project}"
+          @group = group
+          @limit_to_minutes = limit_to_minutes
+          @search_labels = search_labels
+          @issue_is_blocking = issue_is_blocking
+          @dry_run = dry_run
+        end
+
+        def invoke!
+          created_after = utc_time_minus_mins(limit_to_minutes)
+
+          epics = work_items_client.paginated_call(:group_work_items,
+            labels: search_labels.concat(BASE_LABELS_FOR_SEARCH).uniq, state: 'opened', created_after: created_after, extras: [:work_item_fields])
+
+          epics.each do |epic|
+            process_epic(epic)
+          end
+        end
+
+        private
+
+        attr_reader :token, :project, :dry_run, :group, :limit_to_minutes, :search_labels, :issue_is_blocking
+
+        def issue_client
+          @issue_client ||= (dry_run ? GitlabClient::IssuesDryClient : GitlabClient::IssuesClient).new(token: token, project: project)
+        end
+
+        def work_items_client
+          @work_items_client ||= (dry_run ? GitlabClient::WorkItemsDryClient : GitlabClient::WorkItemsClient).new(token: token, project: project, group: group)
+        end
+
+        def label_client
+          @label_client ||= GitlabClient::LabelsClient.new(token: token, project: project)
+        end
+
+        def repository_files_client
+          @repository_files_client ||= GitlabClient::RepositoryFilesClient.new(token: token, project: project, file_path: OPERATIONAL_READINESS_ISSUE_TEMPLATE_PATH, ref: 'master')
+        end
+
+        def utc_time_minus_mins(mins)
+          (Time.now - (mins * 60)).utc.iso8601 if mins
+        end
+
+        def process_epic(epic) # rubocop:disable Metrics/AbcSize
+          epic = fetch_work_item(epic[:iid], work_items_client, [:notes, :linked_items, :labels, :hierarchy])
+
+          return if has_a_child_epic?(epic)
+
+          pre_check_comment = add_operational_readiness_precheck_comment(epic, work_items_client, label_client)
+
+          return unless note_has_emoji?(pre_check_comment, 'white_check_mark') && !has_operational_readiness_issue_linked?(linked_issue_iids(epic), issue_client)
+
+          issue = create_operation_readiness_issue(epic[:title], work_item_author_id(epic), issue_client, repository_files_client)
+
+          link_operation_readiness_issue(issue, epic, link_type, work_items_client)
+
+          post_comment_about_operation_readiness_issue_created(epic, issue, pre_check_comment, work_items_client)
+        end
+
+        def link_type
+          issue_is_blocking ? 'BLOCKED_BY' : 'RELATED'
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/gitlab_client/gitlab_graphql_client.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+
+module GitlabQuality
+  module TestTooling
+    module GitlabClient
+      class GitlabGraphqlClient
+        def initialize(token:, project:, group:, endpoint: nil)
+          @token = token
+          @project = project
+          @group = group
+          @endpoint = endpoint || Runtime::Env.gitlab_graphql_api_base
+        end
+
+        def post(payload)
+          payload = { query: payload } if payload.is_a?(String)
+          request_args = {
+            method: :post,
+            url: endpoint,
+            payload: payload,
+            headers: { 'Authorization' => "Bearer #{token}" },
+            verify_ssl: false
+          }
+          extract_graphql_body(RestClient::Request.execute(request_args))
+        rescue StandardError => e
+          return_response_or_raise(e)
+        end
+
+        private
+
+        attr_reader :project, :token, :endpoint, :group
+
+        def return_response_or_raise(error)
+          return error.response if error.respond_to?(:response) && error.response
+
+          raise error
+        end
+
+        def parse_body(response)
+          JSON.parse(response.body, symbolize_names: true)
+        end
+
+        def extract_graphql_body(graphql_response)
+          parsed_body = parse_body(graphql_response)
+
+          data = parsed_body[:data].to_h
+          data.values[0].to_h
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/gitlab_client/issues_client.rb

@@ -9,6 +9,10 @@ module Gitlab
       get("/projects/#{url_encode(project)}/members/all/#{id}")
     end
 
+    def issue_note_award_emoji(project, issue_id, note_id, options = {})
+      get("/projects/#{url_encode(project)}/issues/#{issue_id}/notes/#{note_id}/award_emoji", query: options)
+    end
+
     def issue_discussions(project, issue_id, options = {})
       get("/projects/#{url_encode(project)}/issues/#{issue_id}/discussions", query: options)
     end
@@ -17,6 +21,16 @@ module Gitlab
       post("/projects/#{url_encode(project)}/issues/#{issue_iid}/discussions", query: options)
     end
 
+    def create_issue_link(project, issue_iid, target_project_id, target_issue_iid, link_type)
+      post("/projects/#{url_encode(project)}/issues/#{issue_iid}/links",
+        query: {
+          target_project_id: target_project_id,
+          target_issue_iid: target_issue_iid,
+          link_type: link_type
+        }.compact
+      )
+    end
+
     def add_note_to_issue_discussion_as_thread(project, issue_id, discussion_id, options = {})
       post("/projects/#{url_encode(project)}/issues/#{issue_id}/discussions/#{discussion_id}/notes", query: options)
     end
@@ -58,6 +72,12 @@ module GitlabQuality
           end
         end
 
+        def related_merge_requests(iid:)
+          handle_gitlab_client_exceptions do
+            client.related_merge_requests(project, iid).auto_paginate
+          end
+        end
+
         def find_issue_discussions(iid:)
           handle_gitlab_client_exceptions do
             client.issue_discussions(project, iid, order_by: 'created_at', sort: 'asc').auto_paginate
@@ -79,6 +99,18 @@ module GitlabQuality
           end
         end
 
+        def create_issue_link(project:, issue_iid:, target_project_id:, target_issue_iid:, link_type: 'is_blocked_by')
+          handle_gitlab_client_exceptions do
+            client.create_issue_link(project, issue_iid, target_project_id, target_issue_iid, link_type)
+          end
+        end
+
+        def issue_links(project:, issue_iid:, options: {})
+          handle_gitlab_client_exceptions do
+            client.issue_links(project, issue_iid, options)
+          end
+        end
+
         def edit_issue(iid:, options: {})
           handle_gitlab_client_exceptions do
             client.edit_issue(project, iid, options)
@@ -97,6 +129,12 @@ module GitlabQuality
           end
         end
 
+        def get_note_award_emojis(issue_iid:, note_id:)
+          handle_gitlab_client_exceptions do
+            client.issue_note_award_emoji(project, issue_iid, note_id)
+          end
+        end
+
         def create_issue_discussion(iid:, note:)
           handle_gitlab_client_exceptions do
             client.create_issue_discussion(project, iid, body: note)

data/lib/gitlab_quality/test_tooling/gitlab_client/issues_dry_client.rb

@@ -20,15 +20,15 @@ module GitlabQuality
         end
 
         def edit_issue_note(issue_iid:, note_id:, note:)
-          puts "The following note would have been edited on #{project}##{issue_iid} (note #{note_id}) issue: #{note}"
+          puts "The following note would have been edited on #{project}##{issue_iid} (note #{note_id}) issue:\n\n #{note}"
         end
 
         def create_issue_discussion(iid:, note:)
-          puts "The following discussion would have been posted on #{project}##{iid} issue: #{note}"
+          puts "The following discussion would have been posted on #{project}##{iid} issue:\n\n #{note}"
         end
 
         def add_note_to_issue_discussion_as_thread(iid:, discussion_id:, note:)
-          puts "The following discussion note would have been posted on #{project}##{iid} (discussion #{discussion_id}) issue: #{note}"
+          puts "The following discussion note would have been posted on #{project}##{iid} (discussion #{discussion_id}) issue:\n\n #{note}"
         end
 
         def upload_file(file_fullpath:)

data/lib/gitlab_quality/test_tooling/gitlab_client/labels_client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module GitlabClient
+      class LabelsClient < GitlabClient
+        def labels(options: {})
+          client.labels(project, options)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/gitlab_client/merge_requests_client.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
+require 'gitlab'
+
+module Gitlab
+  # Monkey patch the Gitlab client to allow passing query options
+  class Client
+    def merge_request_diffs(project, merge_request_iid, options = {})
+      get("/projects/#{url_encode(project)}/merge_requests/#{merge_request_iid}/diffs", query: options).auto_paginate
+    end
+  end
+end
+
 module GitlabQuality
   module TestTooling
     module GitlabClient
@@ -10,6 +21,12 @@ module GitlabQuality
           end
         end
 
+        def merge_request_diffs(merge_request_iid:)
+          handle_gitlab_client_exceptions do
+            client.merge_request_diffs(project, merge_request_iid, per_page: 100)
+          end
+        end
+
         def create_merge_request(title:, source_branch:, target_branch:, description:, labels:, assignee_id: nil, reviewer_ids: [])
           attrs = {
             source_branch: source_branch,
@@ -33,6 +50,10 @@ module GitlabQuality
           merge_request
         end
 
+        def merge_request(id:, options: {})
+          client.merge_request(project, id, options)
+        end
+
         def find(iid: nil, options: {}, &select)
           select ||= :itself
 

data/lib/gitlab_quality/test_tooling/gitlab_client/merge_requests_dry_client.rb

@@ -4,16 +4,6 @@ module GitlabQuality
   module TestTooling
     module GitlabClient
       class MergeRequestsDryClient < MergeRequestsClient
-        def find_merge_request_changes(merge_request_iid:)
-          puts "Finding changes for merge_request_id #{merge_request_iid}"
-          puts "project: #{project}"
-        end
-
-        def merge_request_changed_files(merge_request_iid:)
-          puts "Changed files for #{merge_request_iid}"
-          []
-        end
-
         def find_note(body:, merge_request_iid:)
           puts "Find note for #{merge_request_iid} with body: #{body} for mr_iid: #{merge_request_iid}"
         end