gitlab_quality-test_tooling 2.16.0 → 3.0.0

data/lib/gitlab_quality/test_tooling/code_coverage/lcov_file.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class LcovFile
+        # @param [String] lcov_file_content The content of the lcov file
+        def initialize(lcov_file_content)
+          @lcov_file_content = lcov_file_content
+        end
+
+        # @return [Hash<String, Hash>] The parsed content of the lcov file
+        # @example Return value
+        #   {
+        #     "path/to/file1.rb" => {
+        #       line_coverage: { 1 => 1, 2 => 0 },
+        #       branch_coverage: {},
+        #       total_lines: 2,
+        #       covered_lines: 1,
+        #       percentage: 50.0,
+        #       total_branches: 4,
+        #       covered_branches: 3,
+        #       branch_percentage: 75.0,
+        #       total_functions: 2,
+        #       covered_functions: 1,
+        #       function_percentage: 50.0
+        #     },
+        #     ...
+        #  }
+        def parsed_content
+          return @parsed_content if @parsed_content
+
+          @parsed_content = {}
+          @current_file = nil
+
+          @lcov_file_content.each_line { |line| parse_line(line) }
+
+          include_coverage
+          @parsed_content
+        end
+
+        private
+
+        def parse_line(line)
+          case line
+          when /^SF:(.+)$/
+            register_source_file(::Regexp.last_match(1))
+          when /^DA:(\d+),(\d+)$/
+            register_line_data(::Regexp.last_match(1), ::Regexp.last_match(2))
+          when /^BRDA:(\d+),(\d+),(\d+),(-|\d+)$/
+            register_branch_data(::Regexp.last_match(1), ::Regexp.last_match(4))
+          when /^FNF:(\d+)$/
+            register_functions_found(::Regexp.last_match(1))
+          when /^FNH:(\d+)$/
+            register_functions_hit(::Regexp.last_match(1))
+          when /^BRF:(\d+)$/
+            register_branches_found(::Regexp.last_match(1))
+          when /^BRH:(\d+)$/
+            register_branches_hit(::Regexp.last_match(1))
+          when /^end_of_record$/
+            @current_file = nil
+          end
+        end
+
+        def include_coverage
+          @parsed_content.each_key do |file|
+            @parsed_content[file].merge!(line_coverage_for(file))
+            @parsed_content[file].merge!(branch_coverage_for(file))
+            @parsed_content[file].merge!(function_coverage_for(file))
+          end
+        end
+
+        def line_coverage_for(file)
+          data = @parsed_content[file]
+          return unless data
+
+          total_lines = data[:line_coverage].size
+          covered_lines = data[:line_coverage].values.count(&:positive?)
+
+          {
+            total_lines: total_lines,
+            covered_lines: covered_lines,
+            percentage: total_lines.zero? ? 0.0 : (covered_lines.to_f / total_lines * 100).round(2)
+          }
+        end
+
+        def register_source_file(filename)
+          @current_file = filename.gsub(%r{^\./}, '')
+          @parsed_content[@current_file] = {
+            line_coverage: {},
+            branch_coverage: {},
+            branches: { found: 0, hit: 0 },
+            functions: { found: 0, hit: 0 }
+          }
+        end
+
+        def register_line_data(line_no, count)
+          return unless @current_file
+
+          @parsed_content[@current_file][:line_coverage][line_no.to_i] = count.to_i
+        end
+
+        def register_branch_data(line_no, taken)
+          return unless @current_file
+
+          taken_count = taken == '-' ? 0 : taken.to_i
+          @parsed_content[@current_file][:branch_coverage][line_no.to_i] ||= []
+          @parsed_content[@current_file][:branch_coverage][line_no.to_i] << taken_count
+        end
+
+        def register_functions_found(count)
+          return unless @current_file
+
+          @parsed_content[@current_file][:functions][:found] = count.to_i
+        end
+
+        def register_functions_hit(count)
+          return unless @current_file
+
+          @parsed_content[@current_file][:functions][:hit] = count.to_i
+        end
+
+        def register_branches_found(count)
+          return unless @current_file
+
+          @parsed_content[@current_file][:branches][:found] = count.to_i
+        end
+
+        def register_branches_hit(count)
+          return unless @current_file
+
+          @parsed_content[@current_file][:branches][:hit] = count.to_i
+        end
+
+        def branch_coverage_for(file)
+          data = @parsed_content[file]
+          return {} unless data && data[:branches]
+
+          total = data[:branches][:found]
+          covered = data[:branches][:hit]
+
+          return {} if total.nil? || total.zero?
+
+          {
+            total_branches: total,
+            covered_branches: covered,
+            branch_percentage: (covered.to_f / total * 100).round(2)
+          }
+        end
+
+        def function_coverage_for(file)
+          data = @parsed_content[file]
+          return {} unless data && data[:functions]
+
+          total = data[:functions][:found]
+          covered = data[:functions][:hit]
+
+          return {} if total.nil? || total.zero?
+
+          {
+            total_functions: total,
+            covered_functions: covered,
+            function_percentage: (covered.to_f / total * 100).round(2)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/code_coverage/rspec_report.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class RspecReport
+        # @param [Hash<String, Object>] rspec_report The content of an RSpec
+        #   report
+        def initialize(rspec_report)
+          @rspec_report = rspec_report
+        end
+
+        # @return [Array<Hash<String, String>>] Content of the "examples"
+        #   section of the RSpec report
+        def examples
+          @examples ||= @rspec_report['examples']
+        end
+
+        # @return [Hash<String, Array<String>>] Test files mapped to all feature
+        #   categories they belong to
+        # @example Return value
+        #   {
+        #     "spec/path/to/file_spec.rb" => [
+        #       "feature_category1", "feature_category2"
+        #     ],
+        #     ...
+        #   }
+        def tests_to_categories
+          @tests_to_categories ||= examples.to_a.filter_map do |example|
+            next unless example.is_a?(Hash)
+
+            file_path = example['file_path']
+            next unless file_path.is_a?(String)
+
+            [file_path.gsub('./', ''), Array(example['feature_category']).compact]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/code_coverage/source_file_classifier.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class SourceFileClassifier
+        PATTERNS = {
+          'frontend' => [
+            %r{^app/assets/javascripts/.*\.(js|jsx|ts|tsx|vue)$},
+            %r{^app/assets/stylesheets/.*\.(css|scss)$},
+            %r{^ee/app/assets/javascripts/.*\.(js|jsx|ts|tsx|vue)$},
+            %r{^ee/app/assets/stylesheets/.*\.(css|scss)$},
+            %r{^jh/app/assets/javascripts/.*\.(js|jsx|ts|tsx|vue)$},
+            %r{^spec/frontend/},
+            %r{^ee/spec/frontend/},
+            %r{^spec/frontend_integration/},
+            %r{^app/assets/javascripts/.*\.graphql$},
+            /\.stories\.js$/
+          ],
+          'backend' => [
+            %r{^app/(models|controllers|services|workers|helpers|mailers|policies|presenters|uploaders|validators|enums|events|experiments|facades|channels)/.*\.rb$},
+            %r{^app/serializers/.*\.rb$},
+            %r{^app/graphql/.*\.rb$},
+            %r{^app/components/.*\.rb$},
+            %r{^app/views/.*\.(haml|erb)$},
+            %r{^lib/.*\.rb$},
+            %r{^lib/api/.*\.rb$},
+            %r{^ee/app/.*\.rb$},
+            %r{^ee/lib/.*\.rb$},
+            %r{^jh/app/.*\.rb$},
+            %r{^jh/lib/.*\.rb$},
+            %r{^spec/.*_spec\.rb$},
+            %r{^ee/spec/.*_spec\.rb$},
+            %r{^lib/tasks/.*\.rake$}
+          ],
+          'database' => [
+            %r{^db/migrate/.*\.rb$},
+            %r{^db/post_migrate/.*\.rb$},
+            %r{^ee/db/geo/migrate/.*\.rb$},
+            %r{^db/structure\.sql$},
+            %r{^db/seeds\.rb$},
+            %r{^db/fixtures/}
+          ],
+          'infrastructure' => [
+            /^\.gitlab-ci\.yml$/,
+            %r{^\.gitlab/ci/.*\.(yml|yaml)$},
+            /Dockerfile/,
+            /\.dockerfile$/,
+            %r{^scripts/pipeline/}
+          ],
+          'qa' => [
+            %r{^qa/.*\.rb$}
+          ],
+          'workhorse' => [
+            %r{^workhorse/.*\.go$}
+          ],
+          'tooling' => [
+            %r{^tooling/.*\.(rb|js)$},
+            %r{^rubocop/.*\.rb$},
+            %r{^danger/.*\.rb$},
+            /^\.rubocop\.yml$/
+          ],
+          'configuration' => [
+            %r{^config/.*\.(yml|yaml|rb)$}
+          ]
+        }.freeze
+
+        # Classifies a collection of file paths into their respective types
+        #
+        # @param file_paths [Array<String>] List of file paths to classify
+        # @return [Hash<String, String>] Hash mapping file path to file type
+        def classify(file_paths)
+          file_paths.each_with_object({}) do |file_path, result|
+            result[file_path] = determine_type(file_path)
+          end
+        end
+
+        private
+
+        # Determines the type of a single file based on pattern matching
+        #
+        # @param file_path [String] The file path to classify
+        # @return [String] The file type category
+        def determine_type(file_path)
+          PATTERNS.each do |type, patterns|
+            return type if patterns.any? { |pattern| file_path.match?(pattern) }
+          end
+
+          'other'
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/code_coverage/test_map.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class TestMap
+        SEPARATOR = '/'
+        MARKER = 1
+
+        # @param [Hash] compact_map A nested hash structure where keys are
+        #   source files and values are tree structures with test file paths
+        # @example Example of compact_map for a file tested by 3 spec files
+        #   {
+        #     "app/models/user.rb" => {
+        #       "spec" => {
+        #         "models" => {
+        #           "user_spec.rb" => 1  # MARKER (1) indicates a leaf node
+        #         }
+        #       },
+        #       "ee" => {
+        #         "spec" => {
+        #           "lib" => {
+        #              "ee" => {
+        #                "gitlab" => {
+        #                  "background_migration" => {
+        #                    "delete_invalid_epic_issues_spec.rb"=>1,
+        #                    "backfill_security_policies_spec.rb"=>1
+        #                  }
+        #                }
+        #              }
+        #           }
+        #         }
+        #       }
+        #     }
+        #   }
+        def initialize(compact_map)
+          @compact_map = compact_map
+        end
+
+        # @return [Hash<String, Array<String>>] Source files mapped to all test
+        #   files testing them
+        # @example Return value
+        #   {
+        #     "path/to/file1.rb" => [
+        #       "spec/path/to/file1_spec.rb",
+        #       "spec/path/to/another/file1_spec.rb"
+        #     ],
+        #     ...
+        #   }
+        def source_to_tests
+          @source_to_tests ||= @compact_map.transform_values { |tree| traverse(tree).to_a.uniq }
+        end
+
+        # @return [Hash<String, Array<String>>] Test files mapped to all source
+        #   files tested by them
+        # @example Return value
+        #   {
+        #     "spec/path/to/file1_spec.rb" => [
+        #       "path/to/file1.rb",
+        #       "path/to/file2.rb"
+        #     ],
+        #     ...
+        #   }
+        def test_to_sources
+          @test_to_sources ||= begin
+            test_to_sources = Hash.new { |hash, key| hash[key] = [] }
+
+            @compact_map.each do |source_file, tree|
+              traverse(tree).to_a.each do |test_file|
+                test_to_sources[test_file] << source_file
+              end
+            end
+
+            test_to_sources
+          end
+        end
+
+        private
+
+        def traverse(tree, segments = [], &block)
+          return to_enum(__method__, tree, segments) unless block
+          return yield segments.join(SEPARATOR) if tree == MARKER && !segments.empty?
+
+          tree.each do |key, value|
+            traverse(value, segments + [key], &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/code_coverage/test_report.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class TestReport
+        # @param [Hash<String, Object>] test_report The content of a test
+        #   report (RSpec or Jest)
+        def initialize(test_report)
+          @test_report = test_report
+        end
+
+        # @return [Array<Hash<String, String>>] Content of the "examples"
+        #   section of the test report
+        def examples
+          @examples ||= @test_report['examples']
+        end
+
+        # @return [Hash<String, Array<String>>] Test files mapped to all feature
+        #   categories they belong to
+        # @example Return value
+        #   {
+        #     "spec/path/to/file_spec.rb" => [
+        #       "feature_category1", "feature_category2"
+        #     ],
+        #     ...
+        #   }
+        def tests_to_categories
+          @tests_to_categories ||= examples.to_a.filter_map do |example|
+            next unless example.is_a?(Hash)
+
+            file_path = example['file_path']
+            next unless file_path.is_a?(String)
+
+            [file_path.gsub('./', ''), Array(example['feature_category']).compact]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/code_coverage/utils.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'yaml'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      module Utils
+        def exponential_delay_with_jitter(attempt)
+          exponential_delay = (2**(attempt - 1))
+          jitter = rand # 0-1 seconds
+          exponential_delay + jitter
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module GitlabQuality
           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? }
+            linked_issues(linked_issue_iids, issue_client).any? { |issue| issue.labels.intersect?([OPERATIONAL_READINESS_CHECKLIST_LABEL]) }
           end
 
           def linked_issues(linked_issue_iids, issue_client)

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

@@ -118,6 +118,17 @@ module GitlabQuality
             labels.first.id
           end
 
+          def ids_for_group_labels(labels, group_labels_client)
+            labels.filter_map { |label| get_id_for_group_label(label, group_labels_client) }
+          end
+
+          def get_id_for_group_label(label_name, group_labels_client)
+            labels = group_labels_client.group_labels(options: { search: label_name })
+            return nil if labels.empty?
+
+            labels.first.id
+          end
+
           def extract_id_from_gid(gid)
             gid.to_s.split('/').last.to_i
           end