gitlab_quality-test_tooling 2.9.0 → 2.11.0

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

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module GitlabClient
+      class WorkItemsClient < GitlabGraphqlClient
+        def work_item(workitem_iid:, widgets: [:notes, :linked_items, :labels, :hierarchy])
+          query = <<~GQL
+            query {
+              namespace(fullPath: "#{group}") {
+                workItem(iid: "#{workitem_iid}") {
+                  #{work_item_fields}
+                  #{work_item_widgets(widgets)}
+                }
+              }
+            }
+          GQL
+          post(query)[:workItem]
+        end
+
+        def group_work_items(labels: [], cursor: '', state: 'opened', created_after: nil, extras: [:work_item_fields])
+          query = <<~GQL
+            query {
+              group(fullPath: "#{group}") {
+                workItems(after: "#{cursor}",#{created_after ? " createdAfter: \"#{created_after}\"," : ''} labelName: [#{labels.map { |label| "\"#{label}\"" }.join(', ')}], state: #{state}) {
+                  nodes {
+                    #{construct_extras(extras)}
+                  }
+                  pageInfo {
+                    hasNextPage
+                    endCursor
+                  }
+                }
+              }
+            }
+          GQL
+          begin
+            post(query)[:workItems]
+          rescue StandardError => e
+            puts "Error: #{e}"
+          end
+        end
+
+        def create_discussion(id:, note:)
+          post(
+            <<~GQL
+              mutation CreateDiscussion {
+                  createDiscussion(input: {noteableId: "#{id}", body: "#{note}"}) {
+                      clientMutationId
+                      errors
+                      note {
+                          #{note_fields}
+                      }
+                  }
+              }
+            GQL
+          )
+        end
+
+        def create_discussion_note(work_item_id:, discussion_id:, text:)
+          query = <<~GQL
+            mutation CreateNote {
+                createNote(input: { discussionId: "#{discussion_id}", noteableId: "#{work_item_id}", body: "#{text}" }) {
+                    clientMutationId
+                    errors
+                    note {
+                        #{note_fields}
+                    }
+                }
+            }
+          GQL
+          post(query)
+        end
+
+        def update_note(note_id:, body:)
+          query = <<~GQL
+            mutation UpdateNote {
+                updateNote(input: { body: "#{body}", id: "#{note_id}" }) {
+                    clientMutationId
+                    errors
+                }
+            }
+          GQL
+          post(query)
+        end
+
+        def create_linked_items(work_item_id:, item_ids:, link_type:)
+          query = <<~GQL
+            mutation WorkItemAddLinkedItems {
+                workItemAddLinkedItems(
+                    input: { id: "#{work_item_id}", workItemsIds: [#{item_ids.map { |id| "\"#{id}\"" }.join(', ')}], linkType: #{link_type} }
+                ) {
+                    clientMutationId
+                }
+            }
+          GQL
+          post(query)
+        end
+
+        def add_labels(work_item_id:, label_ids:)
+          query =
+            <<~GQL
+              mutation WorkItemUpdate {
+                  workItemUpdate(input: { id: "#{work_item_id}", labelsWidget: { addLabelIds: [#{label_ids.map { |id| "\"#{id}\"" }.join(', ')}] } }) {
+                      clientMutationId
+                      errors
+                  }
+              }
+            GQL
+          post(query)
+        end
+
+        def paginated_call(method_name, args)
+          results = []
+
+          # Check if the method exists
+          raise ArgumentError, "Unknown method: #{method_name}" unless respond_to?(method_name, true)
+
+          method_obj = method(method_name)
+
+          loop do
+            # Call the method directly using the method object
+            response = method_obj.call(**args)
+
+            break unless response
+
+            results += response[:nodes]
+            break unless response[:pageInfo][:hasNextPage]
+
+            args[:cursor] = response[:pageInfo][:endCursor]
+          end
+
+          results
+        end
+
+        private
+
+        attr_reader :group
+
+        def construct_extras(extras)
+          extras_string = ""
+          extras.each do |extra|
+            next unless respond_to?(extra, true)
+
+            method_obj = method(extra)
+            extras_string += method_obj.call
+            extras_string += "\n"
+          end
+          extras_string
+        end
+
+        # https://docs.gitlab.com/api/graphql/reference/#workitem
+        def work_item_fields
+          <<~GQL
+            author {
+              username
+            }
+            createdAt
+            iid
+            id
+            project {
+              fullPath
+              id
+            }
+            state
+            title
+            webUrl
+            workItemType {
+              name
+            }
+          GQL
+        end
+
+        def work_item_widget_notes
+          <<~GQL
+            ... on WorkItemWidgetNotes {
+              discussions(filter: ONLY_COMMENTS) {
+                nodes {
+                        notes {
+                          nodes {
+                          #{note_fields}
+                          }
+                        }
+                      }
+              }
+            }
+          GQL
+        end
+
+        def work_item_widget_linked_items
+          <<~GQL
+            ... on WorkItemWidgetLinkedItems {
+                linkedItems {
+                    nodes {
+                        linkType
+                        workItem {
+                            #{work_item_fields}
+                        }
+                    }
+                }
+            }
+          GQL
+        end
+
+        def work_item_widget_labels
+          <<~GQL
+            ... on WorkItemWidgetLabels{
+              labels{
+                 nodes{
+                     title
+                 }
+              }
+            }
+          GQL
+        end
+
+        def work_item_widget_hierarchy
+          <<~GQL
+            ... on WorkItemWidgetHierarchy {
+              children {
+                  nodes{
+                   #{work_item_fields}
+                  }
+              }
+            }
+          GQL
+        end
+
+        def work_item_widgets(widgets = [])
+          <<~GQL
+            widgets(onlyTypes: [#{types_for_widgets(widgets)}]) {
+              #{work_item_widget_notes if widgets.include?(:notes)}
+              #{work_item_widget_linked_items if widgets.include?(:linked_items)}
+              #{work_item_widget_labels if widgets.include?(:labels)}
+              #{work_item_widget_hierarchy if widgets.include?(:hierarchy)}
+            }
+          GQL
+        end
+
+        def types_for_widgets(widgets = [])
+          widgets.map(&:upcase).join(', ')
+        end
+
+        # https://docs.gitlab.com/api/graphql/reference/#note
+        def note_fields
+          <<~GQL
+            author {
+              username
+            }
+            awardEmoji {
+              nodes {
+              #{emoji_fields}
+              }
+            }
+            body
+            id
+            url
+            discussion {
+              id
+            }
+          GQL
+        end
+
+        # https://docs.gitlab.com/api/graphql/reference/#awardemoji
+        def emoji_fields
+          <<~GQL
+            emoji
+            name
+            user {
+                username
+            }
+          GQL
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module GitlabClient
+      class WorkItemsDryClient < WorkItemsClient
+        def create_discussion(id:, note:)
+          puts "The following discussion would have been posted on #{project}##{id} epic:\n\n #{note}"
+        end
+
+        def create_discussion_note(work_item_id:, discussion_id:, text:)
+          puts "The following discussion note would have been posted on #{project}##{work_item_id} (discussion #{discussion_id}) text:\n\n #{text}"
+        end
+
+        def create_linked_items(work_item_id:, item_ids:, link_type: 'BLOCKED_BY')
+          puts "The following items would have been linked on #{project}##{work_item_id} (link type: #{link_type}) item_ids: #{item_ids.join(', ')}"
+        end
+
+        def add_labels(work_item_id:, label_ids:)
+          puts "The following labels would have been added to #{project}##{work_item_id} work item: #{label_ids.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/labels_inference.rb

@@ -22,6 +22,10 @@ module GitlabQuality
         ].compact.to_set
       end
 
+      def product_group_from_feature_category(feature_category)
+        categories_mapping.dig(feature_category, 'group')
+      end
+
       private
 
       def categories_mapping

data/lib/gitlab_quality/test_tooling/report/failed_test_issue.rb

@@ -190,7 +190,7 @@ module GitlabQuality
           note_stacktrace = sanitize_stacktrace(stacktrace: note.body, regex: ISSUE_STACKTRACE_REGEX)
           return note_stacktrace if note_stacktrace
 
-          puts "  => [DEBUG] Stacktrace couldn't be found for #{issue.web_url}#note_#{note.id}!"
+          Runtime::Logger.debug "  => Stacktrace couldn't be found for #{issue.web_url}#note_#{note.id}!"
         end
 
         def sanitize_stacktrace(stacktrace:, regex:)
@@ -199,7 +199,7 @@ module GitlabQuality
           if stacktrace_match
             stacktrace_match[:stacktrace].gsub(/^\s*#.*$/, '').gsub(/^[[:space:]]+/, '').strip
           else
-            puts "  => [DEBUG] Stacktrace doesn't match the regex (#{regex})!"
+            Runtime::Logger.debug "  => Stacktrace doesn't match the regex (#{regex})!"
           end
         end
 
@@ -209,7 +209,7 @@ module GitlabQuality
           stack_trace_comparator = StackTraceComparator.new(test_stacktrace, note_stacktrace)
 
           if stack_trace_comparator.lower_or_equal_to_diff_ratio?(max_diff_ratio)
-            puts "  => [DEBUG] Note #{issue.web_url}#note_#{note.id} has an acceptable diff ratio of #{stack_trace_comparator.diff_percent}%."
+            Runtime::Logger.debug "  => Note #{issue.web_url}#note_#{note.id} has an acceptable diff ratio of #{stack_trace_comparator.diff_percent}%."
             # The `Gitlab::ObjectifiedHash` class overrides `#hash` which is used by `Hash#[]=` to compute the hash key.
             # This leads to a `TypeError Exception: no implicit conversion of Hash into Integer` error, so we convert the object to a hash before using it as a Hash key.
             # See:
@@ -217,9 +217,9 @@ module GitlabQuality
             # - https://github.com/NARKOZ/gitlab/commit/cbdbd1e32623f018a8fae39932a8e3bc4d929abb?_pjax=%23js-repo-pjax-container#r44484494
             stack_trace_comparator.diff_ratio
           else
-            puts "  => [DEBUG] Found note #{issue.web_url}#note_#{note.id} but stacktraces are too different (#{stack_trace_comparator.diff_percent}%).\n"
-            puts "  => [DEBUG] Issue stacktrace:\n----------------\n#{note_stacktrace}\n----------------\n"
-            puts "  => [DEBUG] Failure stacktrace:\n----------------\n#{test_stacktrace}\n----------------\n"
+            Runtime::Logger.debug "  => Found note #{issue.web_url}#note_#{note.id} but stacktraces are too different (#{stack_trace_comparator.diff_percent}%).\n"
+            Runtime::Logger.debug "  => Issue stacktrace:\n----------------\n#{note_stacktrace}\n----------------\n"
+            Runtime::Logger.debug "  => Failure stacktrace:\n----------------\n#{test_stacktrace}\n----------------\n"
           end
         end
       end

data/lib/gitlab_quality/test_tooling/report/feature_readiness/report_on_epic.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'pp'
+require 'stringio'
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module FeatureReadiness
+        class ReportOnEpic
+          FEATURE_READINESS_REPORT_COMMENT_ID = '<!-- FEATURE READINESS REPORT COMMENT -->'
+
+          class << self
+            include GitlabQuality::TestTooling::FeatureReadiness::Concerns::WorkItemConcern
+
+            def report(analyzed_epic, work_item_client)
+              must_haves_report_rows = generate_report_rows(analyzed_epic, :must_haves)
+              should_haves_report_rows = generate_report_rows(analyzed_epic, :should_haves)
+
+              existing_note = existing_note_containing_text(FEATURE_READINESS_REPORT_COMMENT_ID, analyzed_epic[:epic_iid], work_item_client)
+
+              if existing_note
+                work_item_client.update_note(note_id: existing_note[:id],
+                  body: comment({ must_haves: must_haves_report_rows, should_haves: should_haves_report_rows }, analyzed_epic).tr('"', "'"))
+              else
+                work_item_client.create_discussion(id: analyzed_epic[:epic_id],
+                  note: comment({ must_haves: must_haves_report_rows, should_haves: should_haves_report_rows }, analyzed_epic).tr('"', "'"))
+              end
+            end
+
+            private
+
+            def generate_report_rows(epic, type)
+              status_checks = check_statuses(epic)
+              create_rows(epic, type, status_checks)
+            end
+
+            def create_rows(epic, type, status_checks)
+              if type == :must_haves
+                [
+                  create_documentation_row(epic, status_checks),
+                  create_feature_flag_row(epic, status_checks),
+                  create_unit_tests_coverage_row(status_checks)
+
+                ]
+              else
+                [
+                  create_feature_tests_row(epic, status_checks),
+                  create_e2e_tests_row(epic, status_checks)
+                ]
+              end
+            end
+
+            def create_documentation_row(epic, status_checks)
+              ["Documentation added?", status_icon(status_checks[:has_docs]),
+                prepend_text('Added in:', format_links(epic[:doc_mrs]))]
+            end
+
+            def create_feature_flag_row(epic, status_checks)
+              ["Feature Flag added?", status_icon(status_checks[:feature_flag_added]),
+                prepend_text('Added in:', format_links(epic[:feature_flag_mrs]))]
+            end
+
+            def create_feature_tests_row(epic, status_checks)
+              ["Feature tests added?", status_icon(status_checks[:has_feature_specs]),
+                format_links(epic[:feature_spec_mrs])]
+            end
+
+            def create_e2e_tests_row(epic, status_checks)
+              ["End-to-end tests added?", status_icon(status_checks[:has_e2e_specs]),
+                format_links(epic[:e2e_spec_mrs])]
+            end
+
+            def create_unit_tests_coverage_row(status_checks)
+              ["Unit tests coverage complete?", status_icon(status_checks[:has_complete_unit_tests]),
+                prepend_text('Coverage missing for:', format_links(status_checks[:missing_specs]))]
+            end
+
+            def prepend_text(prepend_text, text)
+              return "#{prepend_text} #{text}" unless text.empty?
+
+              text
+            end
+
+            def check_statuses(epic)
+              {
+                has_docs: epic[:doc_mrs].any?,
+                feature_flag_added: epic[:feature_flag_mrs].any?,
+                has_feature_specs: epic[:feature_spec_mrs].any?,
+                has_e2e_specs: epic[:e2e_spec_mrs].any?,
+                missing_specs: missing_spec_mrs(epic),
+                has_complete_unit_tests: missing_spec_mrs(epic).empty?
+              }
+            end
+
+            def comment(rows, epic)
+              # Generate markdown table
+              must_haves_table_rows = rows[:must_haves].map do |description, status, links|
+                "| #{description} | #{status} | #{links} |"
+              end.join("\n")
+
+              should_haves_table_rows = rows[:should_haves].map do |description, status, links|
+                "| #{description} | #{status} | #{links} |"
+              end.join("\n")
+
+              <<~COMMENT
+                #{FEATURE_READINESS_REPORT_COMMENT_ID}
+
+                # :vertical_traffic_light: Feature Readiness Evaluation Report
+
+                ### :octagonal_sign: Must haves
+
+                | Evaluation | Result | Notes |
+                |------------|--------|-------|
+                #{must_haves_table_rows}
+
+                ### :warning: Should haves
+
+                | Evaluation | Result | Notes |
+                |------------|--------|-------|
+                #{should_haves_table_rows}
+
+                #{data(epic)}
+
+                ---
+
+                _Please note that this automation is under testing. Please add any feedback on [this issue](https://gitlab.com/gitlab-org/quality/quality-engineering/team-tasks/-/issues/3587)._
+
+              COMMENT
+            end
+
+            def status_icon(condition)
+              condition ? ':white_check_mark:' : ':x:'
+            end
+
+            def format_links(data)
+              return '' if data.empty?
+
+              data.map do |item|
+                item.map { |key, url| "[#{key}](#{url})" }.first
+              end.join(", ")
+            end
+
+            def missing_spec_mrs(epic)
+              epic[:issues].flat_map do |issue|
+                issue[:merge_requests].flat_map do |mr|
+                  next [] unless mr[:files_with_missing_specs]&.any?
+
+                  mr[:files_with_missing_specs].map do |file|
+                    { file => mr[:merge_request_web_url] }
+                  end
+                end.compact
+              end
+            end
+
+            def data(epic)
+              output = StringIO.new
+              PP.pp(epic, output)
+              <<~DATA
+                <details><summary>Expand for data</summary>
+
+                ```ruby
+                #{output.string}
+                ```
+
+                </details>
+              DATA
+            end
+          end
+        end
+      end
+    end
+  end
+end