gitlab_quality-test_tooling 2.10.0 → 2.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 548aaf25c91235b88c18601ebdeb3cecf4c6b6caedbaceb6ddec4bdbaaf3519a
-  data.tar.gz: 04de3d4ce782f42ab487c9d7872f80236d7115250bd28b4a58e02c83aebc0ec9
+  metadata.gz: 7db77718644f72fd0a096182fdf76ad10c912002f0770e245ac782a9b238b690
+  data.tar.gz: 7b67154f177663fdc2bd19882b128e5eaa3540f20c31c50fddcf73c6661590ff
 SHA512:
-  metadata.gz: f5cb5a3f95f291e7f00b7454f9fe211c2f2db662bb08fe47e72c587468dc2658b4ce8019fdaf963de4f5845032863bb71c69d684a5d10702b0efb28caea207eb
-  data.tar.gz: 92ef6b0c7360c676294b9f9e7d15e3ce2b0651ceb5b0e2ccc65a328ae0806f87997a2fed1a74ca398427ba6ecf431299e9bf16e952c4cd1c10cd26332de06332
+  metadata.gz: 0776f0aef2a4076a7a0bfd71c902d57400eea5388982e62583d689038137ed7fe1166368dabfb006999069e32525fd47d752faf92afffa536b9cbe72303c207f
+  data.tar.gz: c3145f170b88abebe7e2a6875d94ccca55fccb370972f37c7679479257186a5e2d73eaedb6bb799139c72bfc32ade74f60e1e5cf07aebb5aa7e3bb8621c7a65d

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    gitlab_quality-test_tooling (2.10.0)
+    gitlab_quality-test_tooling (2.18.0)
       activesupport (>= 7.0, < 7.3)
       amatch (~> 0.4.1)
       fog-google (~> 1.24, >= 1.24.1)
-      gitlab (>= 4.19, < 6.0)
+      gitlab (>= 4.19, < 7.0)
       http (~> 5.0)
       influxdb-client (~> 3.1)
       nokogiri (~> 1.10)
       parallel (>= 1, < 2)
       rainbow (>= 3, < 4)
-      rspec-parameterized (~> 1.0.0)
+      rspec-parameterized (>= 1.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/exe/relate-failure-issue

@@ -58,6 +58,10 @@ options = OptionParser.new do |opts|
     params[:dry_run] = true
   end
 
+  opts.on("--group-similar", "Enable grouping similar issues") do
+    params[:group_similar] = 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}"
@@ -66,6 +70,7 @@ options = OptionParser.new do |opts|
 
   opts.on_tail('-h', '--help', 'Show the usage') do
     puts "Purpose: Relate test failures to failure issues from RSpec report files (JSON or JUnit XML)"
+    puts ""
     puts opts
     exit
   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