gitlab_quality-test_tooling 2.26.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 125bc8b9a38435053e2e82849dd2a41c241d05d47784626234f01702c5619671
-  data.tar.gz: 56255580e30a0fd8896a456e4f079bea4a8de9c2a363d73263dc641f613df786
+  metadata.gz: f037a73b3fd4a445324a37084915ea2d020475cca6f4e3b1d23045f290351082
+  data.tar.gz: e32bc045856df09004e725b9b84317c74ffb66b59ed640b078e292f46a3ff565
 SHA512:
-  metadata.gz: 041e97993894d0edc5d61c0e5e4c5bba688f81fdd92d6bec8d06e19787b3219daad4400d2aedc6c9da2a35e44f526bc8cc4960dce8016ad269f769be482c6ee5
-  data.tar.gz: eb2eef2912be06edf872af18ef1ff8ae1722462b694aa07f57f7a42e138ae8a0327aaa35914a778472e9104b9d08d407075026d2a48ac7ca9b0a5a9ad64944ad
+  metadata.gz: 400c1e51bf57a3f10cdb36c083444153326da8710edd828839881867aed4d9282da4b21fa16357f49bb498ac48199dda888e422e1ddf4f5453769cb5bdc92211
+  data.tar.gz: cc071d0ca3c54a0d3408f6fc91165348c403ab5109c473d7bc518701a17f90d992f02139614dfb99fd53cac7e0ffef688241c7c232cf373344269ffe3e8b4436

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab_quality-test_tooling (2.26.0)
+    gitlab_quality-test_tooling (3.0.0)
       activesupport (>= 7.0, < 7.3)
       amatch (~> 0.4.1)
       fog-google (~> 1.24, >= 1.24.1)

data/exe/test-coverage

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "optparse"
+require "uri"
 
 require_relative "../lib/gitlab_quality/test_tooling"
 
@@ -11,17 +12,22 @@ require_relative '../lib/gitlab_quality/test_tooling/code_coverage/click_house/c
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/coverage_data'
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/lcov_file'
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/artifacts'
-require_relative '../lib/gitlab_quality/test_tooling/code_coverage/rspec_report'
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/test_report'
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/test_map'
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/source_file_classifier'
 
 params = {}
-required_params = [:rspec_reports, :coverage_report, :test_map]
+required_params = [:test_reports, :coverage_report, :test_map, :clickhouse_url, :clickhouse_database, :clickhouse_username]
 
 options = OptionParser.new do |opts|
   opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
 
-  opts.on('--rspec-reports GLOB', 'Glob pattern for RSpec JSON reports (e.g., "rspec/rspec-*.json")') do |pattern|
-    params[:rspec_reports] = pattern
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on('--test-reports GLOB',
+    'Glob pattern for test JSON reports (RSpec or Jest) (e.g., "reports/**/*.json")') do |pattern|
+    params[:test_reports] = pattern
   end
 
   opts.on('--coverage-report PATH', 'Path to the LCOV coverage report (e.g., "coverage/lcov/gitlab.lcov")') do |path|
@@ -32,6 +38,23 @@ options = OptionParser.new do |opts|
     params[:test_map] = path
   end
 
+  opts.on('--clickhouse-url URL', 'ClickHouse server URL') do |url|
+    params[:clickhouse_url] = url
+  end
+
+  opts.on('--clickhouse-database DATABASE', 'ClickHouse database name') do |database|
+    params[:clickhouse_database] = database
+  end
+
+  opts.on('--clickhouse-username USERNAME', 'ClickHouse username') do |username|
+    params[:clickhouse_username] = username
+  end
+
+  opts.separator ""
+  opts.separator "Environment variables:"
+  opts.separator "  GLCI_CLICKHOUSE_METRICS_PASSWORD   ClickHouse password (required, not passed via CLI for security)"
+  opts.separator ""
+
   opts.on('-h', '--help', 'Show the usage') do
     puts opts
     puts "\nExamples:"
@@ -49,63 +72,82 @@ options = OptionParser.new do |opts|
 end
 
 if params.any? && (required_params - params.keys).none?
+  clickhouse_password = ENV.fetch('GLCI_CLICKHOUSE_METRICS_PASSWORD', nil)
+  if clickhouse_password.to_s.strip.empty?
+    puts "Error: GLCI_CLICKHOUSE_METRICS_PASSWORD environment variable must be set and not empty"
+    exit 1
+  end
+
+  [:clickhouse_url, :clickhouse_database, :clickhouse_username].each do |param|
+    if params[param].to_s.strip.empty?
+      puts "Error: --#{param.to_s.tr('_', '-')} cannot be empty"
+      exit 1
+    end
+  end
+
+  begin
+    uri = URI.parse(params[:clickhouse_url])
+    unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+      puts "Error: --clickhouse-url must be a valid HTTP or HTTPS URL"
+      exit 1
+    end
+  rescue URI::InvalidURIError
+    puts "Error: --clickhouse-url is not a valid URL format"
+    exit 1
+  end
+
   artifacts = GitlabQuality::TestTooling::CodeCoverage::Artifacts.new(
-    rspec_reports: params[:rspec_reports],
     coverage_report: params[:coverage_report],
-    test_map: params[:test_map]
+    test_map: params[:test_map],
+    test_reports: params[:test_reports]
   )
 
   coverage_report = artifacts.coverage_report
-  rspec_reports = artifacts.rspec_reports
   test_map = artifacts.test_map
 
   code_coverage_by_source_file = GitlabQuality::TestTooling::CodeCoverage::LcovFile.new(coverage_report).parsed_content
 
   source_file_to_tests = GitlabQuality::TestTooling::CodeCoverage::TestMap.new(test_map).source_to_tests
 
-  tests_to_categories = rspec_reports.reduce({}) do |combined_hash, rspec_report_file|
-    file_categories = GitlabQuality::TestTooling::CodeCoverage::RspecReport.new(rspec_report_file).tests_to_categories
+  # Process test reports
+  tests_to_categories = artifacts.test_reports.reduce({}) do |combined_hash, test_report_file|
+    file_categories = GitlabQuality::TestTooling::CodeCoverage::TestReport.new(test_report_file).tests_to_categories
     combined_hash.merge(file_categories) { |_, old_val, new_val| (old_val + new_val).uniq }
   end
 
   category_owners = GitlabQuality::TestTooling::CodeCoverage::CategoryOwners.new
 
+  # Classify source files by type (frontend, backend, etc.)
+  source_file_classifier = GitlabQuality::TestTooling::CodeCoverage::SourceFileClassifier.new
+  source_file_types = source_file_classifier.classify(code_coverage_by_source_file.keys)
+
   coverage_data = GitlabQuality::TestTooling::CodeCoverage::CoverageData.new(
     code_coverage_by_source_file,
     source_file_to_tests,
     tests_to_categories,
-    category_owners.categories_to_teams
+    category_owners.categories_to_teams,
+    source_file_types
   )
 
-  if ENV.fetch('CLICKHOUSE_URL', nil) &&
-      ENV.fetch('CLICKHOUSE_DATABASE', nil) &&
-      ENV.fetch('CLICKHOUSE_USERNAME', nil) &&
-      ENV.fetch('CLICKHOUSE_PASSWORD', nil)
-
-    clickhouse_data = {
-      url: ENV.fetch('CLICKHOUSE_URL', nil),
-      database: ENV.fetch('CLICKHOUSE_DATABASE', nil),
-      username: ENV.fetch('CLICKHOUSE_USERNAME', nil),
-      password: ENV.fetch('CLICKHOUSE_PASSWORD', nil)
-    }
+  clickhouse_data = {
+    url: params[:clickhouse_url],
+    database: params[:clickhouse_database],
+    username: params[:clickhouse_username],
+    password: clickhouse_password
+  }
 
-    category_owners_table  = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::CategoryOwnersTable.new(**clickhouse_data)
-    coverage_metrics_table = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::CoverageMetricsTable.new(**clickhouse_data)
+  category_owners_table  = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::CategoryOwnersTable.new(**clickhouse_data)
+  coverage_metrics_table = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::CoverageMetricsTable.new(**clickhouse_data)
 
-    category_owners_table.create  if ENV['CLICKHOUSE_CREATE_CATEGORY_OWNERS_TABLE']  == 'true'
-    coverage_metrics_table.create if ENV['CLICKHOUSE_CREATE_COVERAGE_METRICS_TABLE'] == 'true'
+  category_owners_table.create  if ENV['CLICKHOUSE_CREATE_CATEGORY_OWNERS_TABLE']  == 'true'
+  coverage_metrics_table.create if ENV['CLICKHOUSE_CREATE_COVERAGE_METRICS_TABLE'] == 'true'
 
-    if ENV['CLICKHOUSE_PUSH_CATEGORY_DATA'] == 'true'
-      category_owners_table.truncate
-      category_owners_table.push(category_owners.as_db_table)
-    end
-
-    coverage_metrics_table.push(coverage_data.as_db_table)
-  else
-    puts "ClickHouse configuration not found.\n" \
-      'Set CLICKHOUSE_URL, CLICKHOUSE_DATABASE, CLICKHOUSE_USERNAME, ' \
-      'CLICKHOUSE_PASSWORD environment variables to enable ClickHouse export.'
+  if ENV['CLICKHOUSE_PUSH_CATEGORY_DATA'] == 'true'
+    category_owners_table.truncate
+    category_owners_table.push(category_owners.as_db_table)
   end
+
+  coverage_metrics_table.push(coverage_data.as_db_table)
 else
   puts "Missing argument(s). Required arguments are: #{required_params}\nPassed arguments are: #{params}\n"
   puts options

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

@@ -3,6 +3,7 @@
 require 'json'
 require 'stringio'
 require 'zlib'
+require 'active_support/core_ext/object/blank'
 
 module GitlabQuality
   module TestTooling
@@ -10,38 +11,52 @@ module GitlabQuality
       class Artifacts
         # Loads coverage artifacts from the filesystem
         #
-        # @param rspec_reports [String] Glob pattern for RSpec JSON report files (e.g., "rspec/rspec-*.json")
+        # @param test_reports [String] Glob pattern for test JSON report files (RSpec or Jest) (e.g., "reports/**/*.json")
         # @param coverage_report [String] Path to the LCOV coverage report file (e.g., "coverage/lcov/gitlab.lcov")
         # @param test_map [String] Path to the test map file, gzipped or plain JSON (e.g., "crystalball/packed-mapping.json.gz")
-        def initialize(rspec_reports:, coverage_report:, test_map:)
-          @rspec_reports_glob = rspec_reports
+        def initialize(coverage_report:, test_map:, test_reports:)
+          raise ArgumentError, "test_reports cannot be blank" if test_reports.blank?
+
+          @test_reports_glob = test_reports
           @coverage_report_path = coverage_report
           @test_map_path = test_map
         end
 
-        def rspec_reports
-          @rspec_report_files ||= rspec_reports_paths.map do |report_path|
+        # Loads and parses test JSON report files (RSpec or Jest)
+        #
+        # @return [Array<Hash>] Array of parsed JSON test reports
+        # @raise [RuntimeError] If no test reports are found or if JSON parsing fails
+        def test_reports
+          @test_report_files ||= test_reports_paths.map do |report_path|
             JSON.parse(File.read(report_path))
           rescue JSON::ParserError => e
-            raise "Invalid JSON in RSpec report file #{report_path}: #{e.message}"
+            raise "Invalid JSON in test report file #{report_path}: #{e.message}"
           end
         end
 
+        # Loads the LCOV coverage report file
+        #
+        # @return [String] Raw content of the LCOV coverage report
+        # @raise [RuntimeError] If the coverage report file is not found
         def coverage_report
           @coverage_report ||= read_coverage_reports
         end
 
+        # Loads and parses the test map file (supports gzipped or plain JSON)
+        #
+        # @return [Hash] Parsed test map data
+        # @raise [RuntimeError] If the test map file is not found or cannot be parsed
         def test_map
           @test_map ||= fetch_test_map
         end
 
         private
 
-        def rspec_reports_paths
-          @rspec_reports_paths ||= begin
-            paths = Dir.glob(@rspec_reports_glob)
+        def test_reports_paths
+          @test_reports_paths ||= begin
+            paths = Dir.glob(@test_reports_glob)
 
-            raise "No RSpec reports found matching pattern: #{@rspec_reports_glob}" if paths.empty?
+            raise "No test reports found matching pattern: #{@test_reports_glob}" if paths.empty?
 
             paths
           end

data/lib/gitlab_quality/test_tooling/code_coverage/click_house/coverage_metrics_table.rb

@@ -19,7 +19,10 @@ module GitlabQuality
               CREATE TABLE IF NOT EXISTS #{table_name} (
                 timestamp DateTime64(6, 'UTC'),
                 file String,
-                coverage Float64,
+                line_coverage Float64,
+                branch_coverage Nullable(Float64),
+                function_coverage Nullable(Float64),
+                source_file_type String,
                 category Nullable(String),
                 ci_project_id Nullable(UInt32),
                 ci_project_path Nullable(String),
@@ -42,22 +45,47 @@ module GitlabQuality
 
           # @return [Boolean] True if the record is valid, false otherwise
           def valid_record?(record)
-            if record[:file].nil?
-              logger.warn("#{LOG_PREFIX} Skipping record with nil file: #{record}")
-              return false
-            end
+            valid_file?(record) &&
+              valid_line_coverage?(record) &&
+              valid_branch_coverage?(record) &&
+              valid_function_coverage?(record)
+          end
 
-            if record[:coverage].nil?
-              logger.warn("#{LOG_PREFIX} Skipping record with nil coverage: #{record}")
-              return false
-            end
+          # @return [Boolean] True if the file field is present
+          def valid_file?(record)
+            return true unless record[:file].nil?
+
+            logger.warn("#{LOG_PREFIX} Skipping record with nil file: #{record}")
+            false
+          end
 
-            if record[:coverage].nan?
-              logger.warn("#{LOG_PREFIX} Skipping record with NaN coverage: #{record}")
+          # @return [Boolean] True if line_coverage is present and not NaN
+          def valid_line_coverage?(record)
+            if record[:line_coverage].nil?
+              logger.warn("#{LOG_PREFIX} Skipping record with nil line_coverage: #{record}")
               return false
             end
 
-            true
+            return true unless record[:line_coverage].nan?
+
+            logger.warn("#{LOG_PREFIX} Skipping record with NaN line_coverage: #{record}")
+            false
+          end
+
+          # @return [Boolean] True if branch_coverage is not NaN (or is nil)
+          def valid_branch_coverage?(record)
+            return true unless record[:branch_coverage]&.nan?
+
+            logger.warn("#{LOG_PREFIX} Skipping record with NaN branch_coverage: #{record}")
+            false
+          end
+
+          # @return [Boolean] True if function_coverage is not NaN (or is nil)
+          def valid_function_coverage?(record)
+            return true unless record[:function_coverage]&.nan?
+
+            logger.warn("#{LOG_PREFIX} Skipping record with NaN function_coverage: #{record}")
+            false
           end
 
           # @return [Hash] Transformed coverage data including timestamp and CI metadata
@@ -65,7 +93,10 @@ module GitlabQuality
             {
               timestamp: time,
               file: record[:file],
-              coverage: record[:coverage],
+              line_coverage: record[:line_coverage],
+              branch_coverage: record[:branch_coverage],
+              function_coverage: record[:function_coverage],
+              source_file_type: record[:source_file_type],
               category: record[:category],
               **ci_metadata
             }

data/lib/gitlab_quality/test_tooling/code_coverage/click_house/table.rb

@@ -23,6 +23,8 @@ module GitlabQuality
             logger.debug("#{LOG_PREFIX} Starting data export to ClickHouse")
             sanitized_data = sanitize(data)
 
+            return logger.warn("#{LOG_PREFIX} No valid data found after sanitization, skipping ClickHouse export!") if sanitized_data.empty?
+
             client.insert_json_data(table_name, sanitized_data)
             logger.info("#{LOG_PREFIX} Successfully pushed #{sanitized_data.size} records to #{full_table_name}!")
           rescue StandardError => e

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

@@ -12,11 +12,14 @@ module GitlabQuality
         #   mapped to all feature categories they belong to
         # @param [Hash<String, Hash>] categories_to_teams Mapping of categories
         #   to teams (i.e., groups, stages, sections)
-        def initialize(code_coverage_by_source_file, source_file_to_tests, tests_to_categories, categories_to_teams)
+        # @param [Hash<String, String>] source_file_types Mapping of source files
+        #   to their types (frontend, backend, etc.)
+        def initialize(code_coverage_by_source_file, source_file_to_tests, tests_to_categories, categories_to_teams, source_file_types = {})
           @code_coverage_by_source_file = code_coverage_by_source_file
           @source_file_to_tests = source_file_to_tests
           @tests_to_categories = tests_to_categories
           @categories_to_teams = categories_to_teams
+          @source_file_types = source_file_types
         end
 
         # @return [Array<Hash<Symbol, String>>] Mapping of column name to row
@@ -25,7 +28,10 @@ module GitlabQuality
         #   [
         #     {
         #       file: "app/channels/application_cable/channel.rb"
-        #       coverage: 100.0
+        #       line_coverage: 100.0
+        #       branch_coverage: 95.0
+        #       function_coverage: 100.0
+        #       source_file_type: "backend"
         #       category: "team_planning"
         #       group: "project_management"
         #       stage: "plan"
@@ -35,13 +41,25 @@ module GitlabQuality
         #   ]
         def as_db_table
           all_files.flat_map do |file|
-            coverage = @code_coverage_by_source_file[file]&.dig(:percentage)
+            coverage_data = @code_coverage_by_source_file[file]
+            line_coverage = coverage_data&.dig(:percentage)
+            branch_coverage = coverage_data&.dig(:branch_percentage)
+            function_coverage = coverage_data&.dig(:function_percentage)
+
             categories = categories_for(file)
+            base_data = {
+              file: file,
+              line_coverage: line_coverage,
+              branch_coverage: branch_coverage,
+              function_coverage: function_coverage,
+              source_file_type: @source_file_types[file] || 'other'
+            }
+
             if categories.empty?
-              { file: file, coverage: coverage }.merge(no_owner_info)
+              base_data.merge(no_owner_info)
             else
               categories.map do |category|
-                { file: file, coverage: coverage }.merge(owner_info(category))
+                base_data.merge(owner_info(category))
               end
             end
           end

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

@@ -17,7 +17,13 @@ module GitlabQuality
         #       branch_coverage: {},
         #       total_lines: 2,
         #       covered_lines: 1,
-        #       percentage: 50.0
+        #       percentage: 50.0,
+        #       total_branches: 4,
+        #       covered_branches: 3,
+        #       branch_percentage: 75.0,
+        #       total_functions: 2,
+        #       covered_functions: 1,
+        #       function_percentage: 50.0
         #     },
         #     ...
         #  }
@@ -27,18 +33,7 @@ module GitlabQuality
           @parsed_content = {}
           @current_file = nil
 
-          @lcov_file_content.each_line do |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 /^end_of_record$/
-              @current_file = nil
-            end
-          end
+          @lcov_file_content.each_line { |line| parse_line(line) }
 
           include_coverage
           @parsed_content
@@ -46,10 +41,32 @@ module GitlabQuality
 
         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|
-            # TODO: Support branch coverage too
             @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
 
@@ -69,7 +86,12 @@ module GitlabQuality
 
         def register_source_file(filename)
           @current_file = filename.gsub(%r{^\./}, '')
-          @parsed_content[@current_file] = { line_coverage: {}, branch_coverage: {} }
+          @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)
@@ -85,6 +107,62 @@ module GitlabQuality
           @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

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_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/version.rb

@@ -2,6 +2,6 @@
 
 module GitlabQuality
   module TestTooling
-    VERSION = "2.26.0"
+    VERSION = "3.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab_quality-test_tooling
 version: !ruby/object:Gem::Version
-  version: 2.26.0
+  version: 3.0.0
 platform: ruby
 authors:
 - GitLab Quality
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-05 00:00:00.000000000 Z
+date: 2025-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -498,7 +498,9 @@ files:
 - lib/gitlab_quality/test_tooling/code_coverage/coverage_data.rb
 - lib/gitlab_quality/test_tooling/code_coverage/lcov_file.rb
 - lib/gitlab_quality/test_tooling/code_coverage/rspec_report.rb
+- lib/gitlab_quality/test_tooling/code_coverage/source_file_classifier.rb
 - lib/gitlab_quality/test_tooling/code_coverage/test_map.rb
+- lib/gitlab_quality/test_tooling/code_coverage/test_report.rb
 - lib/gitlab_quality/test_tooling/code_coverage/utils.rb
 - lib/gitlab_quality/test_tooling/concerns/find_set_dri.rb
 - lib/gitlab_quality/test_tooling/failed_jobs_table.rb