gitlab_quality-test_tooling 2.10.0 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 548aaf25c91235b88c18601ebdeb3cecf4c6b6caedbaceb6ddec4bdbaaf3519a
-  data.tar.gz: 04de3d4ce782f42ab487c9d7872f80236d7115250bd28b4a58e02c83aebc0ec9
+  metadata.gz: ed414366558c053e3eaef1211a9bd431899106af38b4f1f80b8a68334294b633
+  data.tar.gz: fb31640455e0cda1ca5551f30c804c38d03c17d93e17e6f6a267347c7460dd18
 SHA512:
-  metadata.gz: f5cb5a3f95f291e7f00b7454f9fe211c2f2db662bb08fe47e72c587468dc2658b4ce8019fdaf963de4f5845032863bb71c69d684a5d10702b0efb28caea207eb
-  data.tar.gz: 92ef6b0c7360c676294b9f9e7d15e3ce2b0651ceb5b0e2ccc65a328ae0806f87997a2fed1a74ca398427ba6ecf431299e9bf16e952c4cd1c10cd26332de06332
+  metadata.gz: c95d137404f52c79e6679c74327124bf3288b074c582cc3caf90a0125dc1f1b19e2ff08d71053c60f01d53db99e4aa2bacebae69f8f2f5c1e5897dd637b602e2
+  data.tar.gz: ebb57aa657a848b93d4aeb763bcfa9f682b09d2e4f0d79aa17894536e78feaed1769fb843fb739c6d60fa71522db6a7f1210e3b21ae2ef97094ab9d698412c1f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab_quality-test_tooling (2.10.0)
+    gitlab_quality-test_tooling (2.12.0)
       activesupport (>= 7.0, < 7.3)
       amatch (~> 0.4.1)
       fog-google (~> 1.24, >= 1.24.1)
@@ -11,7 +11,7 @@ PATH
       nokogiri (~> 1.10)
       parallel (>= 1, < 2)
       rainbow (>= 3, < 4)
-      rspec-parameterized (~> 1.0.0)
+      rspec-parameterized (>= 1.0.0, < 3.0)
       table_print (= 1.5.7)
       zeitwerk (>= 2, < 3)
 

data/README.md

@@ -257,17 +257,34 @@ Usage: exe/update-test-meta [options]
     -h, --help                       Show the usage
 ```
 
-### `exe/feature-readiness-check`
+### `exe/feature-readiness-checklist`
 
 ```shell
 Purpose: Conditionally create operational readiness checklist and link it to the epic
-Usage: exe/feature-readiness-check [options]
-    -p, --project PROJECT            Can be an integer or a group/project string
-    -g, --group GROUP                Can be an integer or a group/project string
+Usage: exe/feature-readiness-checklist [options]
+    -p, --project PROJECT            Name of the project
+    -g, --group GROUP                Name of the group
+    -t, --token TOKEN                A valid access token with `api` scope and Maintainer permission in PROJECT
+    -l, --search_labels LABELS       A comma seperated list of labels to filter the epics on
+    -m, --minutes MINUTES            Limit the search to issues and epics created with last MINUTES. Optional.
+    -b, --blocking                   Block the epic by any issues created and linked to it
+        --dry-run                    Perform a dry-run (don't create branches, commits or MRs)
+    -v, --version                    Show the version
+    -h, --help                       Show the usage
+```
+
+### `exe/feature-readiness-evaluation`
+
+```shell
+Purpose: Evaluate MRs for multiple feature readiness criteria and report the status to the corresponding epic
+Usage: exe/feature-readiness-evaluation [options]
+    -p, --project PROJECT            Name of the project
+    -g, --group GROUP                Name of the group
     -t, --token TOKEN                A valid access token with `api` scope and Maintainer permission in PROJECT
     -l, --search_labels LABELS       A comma seperated list of labels to filter the epics on
     -m, --minutes MINUTES            Limit the search to issues and epics created with last MINUTES. Optional.
-    -b, --blocking                   Any issues created and linked to the epic will block the epic
+    -e, --epic-iid EPIC_IID          evaluate an epic with iid
+    -o, --operational-readinessr     Perform the operational readiness checklist automation
         --dry-run                    Perform a dry-run (don't create branches, commits or MRs)
     -v, --version                    Show the version
     -h, --help                       Show the usage

data/exe/{feature-readiness-check → feature-readiness-checklist}

@@ -9,10 +9,10 @@ params = {}
 options = OptionParser.new do |opts|
   opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
 
-  opts.on('-p', '--project PROJECT', String, 'Can be an integer or a group/project string') do |project|
+  opts.on('-p', '--project PROJECT', String, 'Name of the project') do |project|
     params[:project] = project
   end
-  opts.on('-g', '--group GROUP', String, 'Can be an integer or a group/project string') do |group|
+  opts.on('-g', '--group GROUP', String, 'Name of the group') do |group|
     params[:group] = group
   end
 

data/exe/feature-readiness-evaluation

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require 'active_support/core_ext/hash'
+
+require_relative "../lib/gitlab_quality/test_tooling"
+params = {}
+
+options = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+  opts.on('-p', '--project PROJECT', String, 'Name of the project') do |project|
+    params[:project] = project
+  end
+  opts.on('-g', '--group GROUP', String, 'Name of the group') do |group|
+    params[:group] = group
+  end
+
+  opts.on('-t', '--token TOKEN', String, 'A valid access token with `api` scope and Maintainer permission in PROJECT') do |token|
+    params[:token] = token
+  end
+
+  opts.on('-l', '--search_labels LABELS', String, 'A comma seperated list of labels to filter the epics on') do |search_labels|
+    params[:search_labels] = search_labels.split(',')
+  end
+
+  opts.on('-m', '--minutes MINUTES', Integer, 'Limit the search to issues and epics created with last MINUTES. Optional.') do |minutes|
+    params[:limit_to_minutes] = minutes
+  end
+
+  opts.on('-ei', '--epic-iid EPIC_IID', String, 'evaluate an epic with iid') do |epic_iid|
+    params[:epic_iid] = epic_iid
+  end
+
+  opts.on('--dry-run', "Perform a dry-run (don't create branches, commits or MRs)") do
+    params[:dry_run] = true
+  end
+
+  opts.on_tail('-v', '--version', 'Show the version') do
+    require_relative "../lib/gitlab_quality/test_tooling/version"
+    puts "#{$PROGRAM_NAME} : #{GitlabQuality::TestTooling::VERSION}"
+    exit
+  end
+
+  opts.on_tail('-h', '--help', 'Show the usage') do
+    puts "Purpose: Evaluate MRs for multiple feature readiness criteria and report the status to the corresponding epic"
+    puts opts
+    exit
+  end
+
+  opts.parse(ARGV)
+end
+
+raise ArgumentError, "Missing argument(s). Required arguments are: --project, --group, --token" if params.empty? || ([:project, :group, :token] - params.keys).any?
+
+if params.any?
+  GitlabQuality::TestTooling::FeatureReadiness::Evaluation.new(**params).invoke!
+else
+  puts options
+  exit 1
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/analyzed_items/analyzed_epic.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      module AnalyzedItems
+        class AnalyzedEpic
+          include Concerns::WorkItemConcern
+
+          def initialize(epic:, token:, project:, group:, dry_run:)
+            @token = token
+            @project = project
+            @group = group
+            @dry_run = dry_run
+            @epic = epic
+            @analyzed_issues = []
+          end
+
+          def analyze
+            issue_iids = get_issue_iids(epic, project)
+            return if issue_iids.none?
+
+            open_issues = fetch_open_issues(issue_iids)
+
+            puts "\nProcessing epic: #{epic[:webUrl]} with #{open_issues.count} open feature addition issues."
+
+            process_issues(open_issues)
+          end
+
+          def process_issues(issues)
+            @analyzed_issues.concat(
+              issues.map do |issue|
+                AnalyzedIssue.new(issue: issue, token: token, project: project, group: group, dry_run: dry_run)
+                             .tap(&:analyze)
+                             .result
+              end
+            )
+          end
+
+          def result
+            {
+              epic_iid: epic[:iid],
+              epic_id: epic[:id],
+              epic_web_url: epic[:webUrl],
+              issues: analyzed_issues,
+              doc_mrs: doc_mrs,
+              feature_spec_mrs: feature_spec_mrs,
+              e2e_spec_mrs: e2e_spec_mrs,
+              feature_flag_mrs: feature_flag_mrs
+            }
+          end
+
+          private
+
+          attr_reader :epic, :token, :project, :dry_run, :group, :analyzed_issues
+
+          def work_items_client
+            @work_items_client ||= (dry_run ? GitlabClient::WorkItemsDryClient : GitlabClient::WorkItemsClient).new(token: token, project: project, group: group)
+          end
+
+          def issue_client
+            @issue_client ||= (dry_run ? GitlabClient::IssuesDryClient : GitlabClient::IssuesClient).new(token: token, project: project)
+          end
+
+          def fetch_open_issues(issue_iids)
+            issue_client.find_issues(
+              options: {
+                iids: issue_iids,
+                labels: Evaluation::BASE_LABELS_FOR_SEARCH,
+                state: 'opened'
+              }
+            )
+          end
+
+          def doc_mrs
+            analyzed_issues.flat_map { |issue| issue[:doc_mrs].any? ? issue[:doc_mrs] : [] }
+          end
+
+          def feature_spec_mrs
+            analyzed_issues.flat_map { |issue| issue[:feature_spec_mrs].any? ? issue[:feature_spec_mrs] : [] }
+          end
+
+          def e2e_spec_mrs
+            analyzed_issues.flat_map { |issue| issue[:e2e_spec_mrs].any? ? issue[:e2e_spec_mrs] : [] }
+          end
+
+          def feature_flag_mrs
+            analyzed_issues.flat_map { |issue| issue[:feature_flag_mrs].any? ? issue[:feature_flag_mrs] : [] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/analyzed_items/analyzed_issue.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      module AnalyzedItems
+        class AnalyzedIssue
+          def initialize(issue:, token:, project:, group:, dry_run:)
+            @issue = issue
+            @token = token
+            @project = project
+            @group = group
+            @dry_run = dry_run
+            @analyzed_merge_requests = []
+          end
+
+          def analyze
+            contributing_mrs = contributing_mrs_for_issue(issue)
+            return if contributing_mrs.empty?
+
+            @analyzed_merge_requests.concat(
+              contributing_mrs
+                .reject { |mr| skip_merge_request?(mr, issue) }
+                .map do |merge_request|
+                AnalyzedMergeRequest.new(merge_request: merge_request, token: token, project: project, group: group, dry_run: dry_run)
+                                    .tap(&:analyze)
+                                    .result
+              end
+            )
+          end
+
+          def result
+            {
+              issue_iid: issue.iid,
+              issue_web_url: issue.web_url,
+              merge_requests: analyzed_merge_requests,
+              doc_mrs: doc_mrs,
+              feature_spec_mrs: feature_spec_mrs,
+              e2e_spec_mrs: e2e_spec_mrs,
+              feature_flag_mrs: feature_flag_mrs
+            }
+          end
+
+          private
+
+          attr_reader :issue, :token, :project, :group, :dry_run, :analyzed_merge_requests
+
+          def contributing_mrs_for_issue(issue)
+            related_mrs = issue_client.related_merge_requests(iid: issue.iid)
+
+            return [] if related_mrs.empty?
+
+            related_mrs.select do |mr|
+              mr.description&.include?("##{issue.iid}") || mr.description&.include?(issue.web_url)
+            end
+          end
+
+          def skip_merge_request?(merge_request, issue)
+            if (merge_request.target_project_id != issue.project_id) || (merge_request.draft == true)
+              puts "Skipping: #{merge_request.web_url} #{merge_request.draft == true ? 'as it is a draft' : 'due to different project id'}"
+              return true
+            end
+
+            false
+          end
+
+          def issue_client
+            @issue_client ||= (dry_run ? GitlabClient::IssuesDryClient : GitlabClient::IssuesClient).new(token: token, project: project)
+          end
+
+          def doc_mrs
+            analyzed_merge_requests
+              .select { |mr| mr[:has_docs] }
+              .map.with_index(1) { |mr, index| { "MR#{index}" => mr[:merge_request_web_url] } }
+          end
+
+          def feature_spec_mrs
+            analyzed_merge_requests.select { |mr| mr[:has_feature_specs] }.map.with_index(1) { |mr, index| { "MR#{index}" => mr[:merge_request_web_url] } }
+          end
+
+          def e2e_spec_mrs
+            analyzed_merge_requests.select { |mr| mr[:has_e2e_specs] }.map.with_index(1) { |mr, index| { "MR#{index}" => mr[:merge_request_web_url] } }
+          end
+
+          def feature_flag_mrs
+            analyzed_merge_requests.select { |mr| mr[:added_feature_flag] }.map.with_index(1) { |mr, index| { "MR#{index}" => mr[:merge_request_web_url] } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/analyzed_items/analyzed_merge_request.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      module AnalyzedItems
+        class AnalyzedMergeRequest
+          CODE_DIRECTORIES = %w[app lib config keeps scripts db].freeze
+          ADDITIONS_THRESHOLD = 5
+          CODE_FILES_EXT = "rb|js|vue"
+          SPEC_FILES_EXT = "rb|js"
+          DOC_FILES_EXT = "tmpl|yaml|yml|md"
+
+          def initialize(merge_request:, token:, project:, group:, dry_run:)
+            @merge_request = merge_request
+            @token = token
+            @project = project
+            @group = group
+            @dry_run = dry_run
+          end
+
+          def analyze
+            @files_with_missing_specs ||= fetch_files_with_missing_specs
+          end
+
+          def result
+            {
+              merge_request_iid: merge_request.iid,
+              merge_request_web_url: merge_request.web_url,
+              files_with_missing_specs: files_with_missing_specs,
+              has_docs: has_docs?,
+              has_feature_specs: has_feature_specs?,
+              has_e2e_specs: has_e2e_specs?,
+              added_feature_flag: added_feature_flag?
+            }
+          end
+
+          private
+
+          attr_reader :merge_request, :token, :project, :group, :dry_run, :files_with_missing_specs
+
+          def merge_request_client
+            @merge_request_client ||= (dry_run ? GitlabClient::MergeRequestsDryClient : GitlabClient::MergeRequestsClient).new(token: token, project: project)
+          end
+
+          def has_docs?
+            doc_diffs.any?
+          end
+
+          def has_feature_specs?
+            spec_diffs('features/').map { |diff| has_significant_addition?(diff) }.any?
+          end
+
+          def added_feature_flag?
+            filter_diffs(%r{^(ee/)?config/feature_flags/.*\.yml$}).any?(&:new_file)
+          end
+
+          def has_e2e_specs?
+            qa_spec_diffs.map { |diff| has_significant_addition?(diff) }.any?
+          end
+
+          def fetch_files_with_missing_specs
+            code_paths_with_missing_specs = []
+
+            CODE_DIRECTORIES.each do |dir|
+              code_diffs = diffs_for_dir(dir, CODE_FILES_EXT)
+              sp_diffs = spec_diffs
+              code_paths_with_missing_specs << collect_paths_with_missing_specs(code_diffs, sp_diffs)
+            end
+
+            code_paths_with_missing_specs.flatten
+          end
+
+          def collect_paths_with_missing_specs(code_diffs, sp_diffs)
+            result_array = []
+            code_diffs.each do |code_diff|
+              result_array << code_diff.new_path if has_significant_addition?(code_diff) && !skip_file?(code_diff.new_path) && !has_matching_spec_for_code?(code_diff, sp_diffs)
+            end
+
+            result_array
+          end
+
+          def has_matching_spec_for_code?(code_diff, sp_diffs)
+            spec_file_names = get_spec_file_names(code_diff.new_path)
+            sp_diffs.any? { |diff| ends_with_names?(diff.new_path, spec_file_names) }
+          end
+
+          def diffs
+            @diffs ||= merge_request_client.merge_request_diffs(merge_request_iid: merge_request.iid)
+          end
+
+          def has_significant_addition?(diff_obj)
+            content_lines = diff_obj.diff.split("\n")
+
+            additions = content_lines.count { |line| line.start_with?("+") }
+            subtractions = content_lines.count { |line| line.start_with?("-") }
+
+            # Return true if additions are above threshold and there are equal or more additions than subtractions
+            additions >= ADDITIONS_THRESHOLD && additions >= subtractions
+          end
+
+          def filter_diffs(pattern)
+            diffs.select { |diff| diff.new_path =~ pattern }
+          end
+
+          def diffs_for_dir(dir, ext)
+            filter_diffs(%r{^(ee/#{Regexp.escape(dir)}|#{Regexp.escape(dir)})/.*\.(#{ext})$})
+          end
+
+          def spec_diffs(spec_sub_dir = '')
+            filter_diffs(%r{^(spec|ee/spec)/#{spec_sub_dir}.+_spec\.(#{SPEC_FILES_EXT})$})
+          end
+
+          def qa_spec_diffs
+            filter_diffs(%r{^qa/qa/specs/features/.+(_spec|_shared_examples|_shared_context)\.rb$})
+          end
+
+          def doc_diffs
+            filter_diffs(%r{^doc/.+\.(#{DOC_FILES_EXT})$}o)
+          end
+
+          def get_spec_file_names(path)
+            filename = File.basename(path, ".*")
+
+            %W[#{filename}_spec #{filename}_shared_examples]
+          end
+
+          def ends_with_names?(path, target_names)
+            [File.basename(path, File.extname(path))].intersect?(target_names)
+          end
+
+          def skip_file?(path)
+            path.end_with?('index.js')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module GitlabQuality
           OPERATIONAL_READINESS_NOTE_ID = '<!-- OPERATIONAL READINESS PRECHECK COMMENT -->'
           OPERATIONAL_READINESS_TRACKING_LABEL = 'tracking operational readiness'
 
-          def add_operational_readiness_precheck_comment(work_item, client)
+          def add_operational_readiness_precheck_comment(work_item, work_items_client, label_client)
             comment = <<~COMMENT
               #{OPERATIONAL_READINESS_NOTE_ID}
               ## Operational Readiness Pre-Check
@@ -24,21 +24,21 @@ module GitlabQuality
               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]), work_item[:id], client)
+            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, client)
+            discussion = existing_note_containing_text(OPERATIONAL_READINESS_NOTE_ID, work_item[:iid], work_items_client)
 
             return discussion if discussion
 
-            client.create_discussion(id: work_item[:id], note: comment)
+            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, client)
+            existing_note_containing_text(OPERATIONAL_READINESS_NOTE_ID, work_item[:iid], work_items_client)
           end
 
-          def existing_note_containing_text(text, work_item, client)
-            work_item = fetch_work_item(work_item[:iid], client)
+          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) }
@@ -64,12 +64,26 @@ module GitlabQuality
             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)
-            client.work_item(workitem_iid: iid)
+          def fetch_work_item(iid, client, widgets = [])
+            client.work_item(workitem_iid: iid, widgets: widgets)
           end
 
           def has_a_child_epic?(epic)
@@ -92,11 +106,11 @@ module GitlabQuality
             label_ids.map { |label_id| "gid://gitlab/Label/#{label_id}" }
           end
 
-          def ids_for_labels(labels = [])
-            labels.map { |label| get_id_for_label(label) }
+          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)
+          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?

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

@@ -14,7 +14,7 @@ module GitlabQuality
 
         def initialize(token:, project: nil, group: nil, limit_to_minutes: nil, search_labels: [], issue_is_blocking: false, dry_run: false)
           @token = token
-          @project = project
+          @project = "#{group}/#{project}"
           @group = group
           @limit_to_minutes = limit_to_minutes
           @search_labels = search_labels
@@ -26,7 +26,7 @@ module GitlabQuality
           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), state: 'opened', created_after: created_after, extras: [:work_item_fields])
+            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)
@@ -58,11 +58,11 @@ module GitlabQuality
         end
 
         def process_epic(epic) # rubocop:disable Metrics/AbcSize
-          epic = fetch_work_item(epic[:iid], work_items_client)
+          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)
+          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)
 

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

@@ -72,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

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

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

@@ -3,15 +3,14 @@
 module GitlabQuality
   module TestTooling
     module GitlabClient
-      # The GitLab client is used for API access: https://github.com/NARKOZ/gitlab
       class WorkItemsClient < GitlabGraphqlClient
-        def work_item(workitem_iid: nil)
+        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}
+                  #{work_item_widgets(widgets)}
                 }
               }
             }
@@ -19,7 +18,7 @@ module GitlabQuality
           post(query)[:workItem]
         end
 
-        def group_work_items(labels: [], cursor: '', state: 'opened', created_after: nil, extras: [])
+        def group_work_items(labels: [], cursor: '', state: 'opened', created_after: nil, extras: [:work_item_fields])
           query = <<~GQL
             query {
               group(fullPath: "#{group}") {
@@ -73,6 +72,18 @@ module GitlabQuality
           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 {
@@ -160,50 +171,76 @@ module GitlabQuality
           GQL
         end
 
-        def work_item_widgets
+        def work_item_widget_notes
           <<~GQL
-            widgets(onlyTypes: [LINKED_ITEMS, NOTES, LABELS, HIERARCHY]) {
-              ... on WorkItemWidgetNotes {
-                discussions(filter: ONLY_COMMENTS) {
-                  nodes {
-                          notes {
-                            nodes {
-                            #{note_fields}
-                            }
+            ... on WorkItemWidgetNotes {
+              discussions(filter: ONLY_COMMENTS) {
+                nodes {
+                        notes {
+                          nodes {
+                          #{note_fields}
                           }
                         }
-                }
-              }
-              ... on WorkItemWidgetLinkedItems {
-                  linkedItems {
-                      nodes {
-                          linkType
-                          workItem {
-                              #{work_item_fields}
-                          }
                       }
-                  }
               }
+            }
+          GQL
+        end
 
-              ... on WorkItemWidgetLabels{
-                labels{
-                   nodes{
-                       title
-                   }
+        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
 
-              ... on WorkItemWidgetHierarchy {
-                children {
-                    nodes{
-                     #{work_item_fields}
-                    }
-                }
+        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

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

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

@@ -318,7 +318,7 @@ module GitlabQuality
           initialize_gitlab_ops_client
 
           if Runtime::Env.ci_pipeline_url.include?('ops.gitlab.net')
-            pipeline = ops_gitlab_client.find_pipeline(project, Runtime::Env.ci_pipeline_id.to_i)
+            pipeline = ops_gitlab_client.find_pipeline(Runtime::Env.ci_project_path, Runtime::Env.ci_pipeline_id.to_i)
             generate_ops_gitlab_diff(pipeline)
           else
             pipeline = gitlab.find_pipeline(project, Runtime::Env.ci_pipeline_id.to_i)
@@ -342,6 +342,8 @@ module GitlabQuality
         end
 
         def fetch_deployment_info(pipeline)
+          return 'No pipeline name set.' unless Runtime::Env.ci_pipeline_name
+
           pipeline_deploy_version = Runtime::Env.ci_pipeline_name.match(/(\d+\.\d+\.\d+)(?:-|$)/)&.captures&.first
           deployments = fetch_deployments(ops_gitlab_client, pipeline)
           found_deployment = find_matching_deployment(pipeline_deploy_version, deployments)

data/lib/gitlab_quality/test_tooling/version.rb

@@ -2,6 +2,6 @@
 
 module GitlabQuality
   module TestTooling
-    VERSION = "2.10.0"
+    VERSION = "2.12.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab_quality-test_tooling
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.12.0
 platform: ruby
 authors:
 - GitLab Quality
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 2025-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -380,16 +380,22 @@ dependencies:
   name: rspec-parameterized
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: table_print
   requirement: !ruby/object:Gem::Requirement
@@ -431,7 +437,8 @@ executables:
 - detect-infrastructure-failures
 - existing-test-health-issue
 - failed-test-issues
-- feature-readiness-check
+- feature-readiness-checklist
+- feature-readiness-evaluation
 - flaky-test-issues
 - generate-test-session
 - knapsack-report-issues
@@ -463,7 +470,8 @@ files:
 - exe/detect-infrastructure-failures
 - exe/existing-test-health-issue
 - exe/failed-test-issues
-- exe/feature-readiness-check
+- exe/feature-readiness-checklist
+- exe/feature-readiness-evaluation
 - exe/flaky-test-issues
 - exe/generate-test-session
 - exe/knapsack-report-issues
@@ -479,8 +487,12 @@ files:
 - lib/gitlab_quality/test_tooling.rb
 - lib/gitlab_quality/test_tooling/concerns/find_set_dri.rb
 - lib/gitlab_quality/test_tooling/failed_jobs_table.rb
+- lib/gitlab_quality/test_tooling/feature_readiness/analyzed_items/analyzed_epic.rb
+- lib/gitlab_quality/test_tooling/feature_readiness/analyzed_items/analyzed_issue.rb
+- lib/gitlab_quality/test_tooling/feature_readiness/analyzed_items/analyzed_merge_request.rb
 - lib/gitlab_quality/test_tooling/feature_readiness/concerns/issue_concern.rb
 - lib/gitlab_quality/test_tooling/feature_readiness/concerns/work_item_concern.rb
+- lib/gitlab_quality/test_tooling/feature_readiness/evaluation.rb
 - lib/gitlab_quality/test_tooling/feature_readiness/operational_readiness_check.rb
 - lib/gitlab_quality/test_tooling/gitlab_client/branches_client.rb
 - lib/gitlab_quality/test_tooling/gitlab_client/branches_dry_client.rb
@@ -507,6 +519,7 @@ files:
 - lib/gitlab_quality/test_tooling/report/concerns/results_reporter.rb
 - lib/gitlab_quality/test_tooling/report/concerns/utils.rb
 - lib/gitlab_quality/test_tooling/report/failed_test_issue.rb
+- lib/gitlab_quality/test_tooling/report/feature_readiness/report_on_epic.rb
 - lib/gitlab_quality/test_tooling/report/flaky_test_issue.rb
 - lib/gitlab_quality/test_tooling/report/generate_test_session.rb
 - lib/gitlab_quality/test_tooling/report/health_problem_reporter.rb