gitlab_quality-test_tooling 2.27.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9627a5294f93832f5513406c664eb60589037f0317bca00ad7dd7d9a6668ee85
-  data.tar.gz: 540672e53766c7c64743575b77600ffeda9916e7aa8337d269405eadb80bec12
+  metadata.gz: f037a73b3fd4a445324a37084915ea2d020475cca6f4e3b1d23045f290351082
+  data.tar.gz: e32bc045856df09004e725b9b84317c74ffb66b59ed640b078e292f46a3ff565
 SHA512:
-  metadata.gz: a5c0623b34d029ac924e8cb52ba3b8e22999c246c17b947c29995ccdb61d1b7738fa57428afea6a8bf77138b235e780dc6d2e53e270b5691762e083025249782
-  data.tar.gz: 1e9f61e86067efcd19c3f6e945d75e8bbc797383c3c7e0f0b5f9aa656edf020fa42a4236f49a02b63a6651af2a3f81a9b1433cde5853d4d2f0b16d9875304f5a
+  metadata.gz: 400c1e51bf57a3f10cdb36c083444153326da8710edd828839881867aed4d9282da4b21fa16357f49bb498ac48199dda888e422e1ddf4f5453769cb5bdc92211
+  data.tar.gz: cc071d0ca3c54a0d3408f6fc91165348c403ab5109c473d7bc518701a17f90d992f02139614dfb99fd53cac7e0ffef688241c7c232cf373344269ffe3e8b4436

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab_quality-test_tooling (2.27.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

@@ -12,12 +12,12 @@ 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 = [:coverage_report, :test_map, :clickhouse_url, :clickhouse_database, :clickhouse_username]
+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]"
@@ -26,14 +26,10 @@ options = OptionParser.new do |opts|
   opts.separator "Options:"
 
   opts.on('--test-reports GLOB',
-    'Glob pattern for test JSON reports (RSpec or Jest) (e.g., "reports/**/*.json"). Takes precedence over --rspec-reports if both are provided.') do |pattern|
+    'Glob pattern for test JSON reports (RSpec or Jest) (e.g., "reports/**/*.json")') do |pattern|
     params[:test_reports] = pattern
   end
 
-  opts.on('--rspec-reports GLOB', '[DEPRECATED] Use --test-reports instead. Glob pattern for RSpec JSON reports. Ignored if --test-reports is also provided.') do |pattern|
-    params[:rspec_reports] = pattern
-  end
-
   opts.on('--coverage-report PATH', 'Path to the LCOV coverage report (e.g., "coverage/lcov/gitlab.lcov")') do |path|
     params[:coverage_report] = path
   end
@@ -100,17 +96,10 @@ if params.any? && (required_params - params.keys).none?
     exit 1
   end
 
-  # Validate that at least one of test_reports or rspec_reports is provided
-  if params[:test_reports].nil? && params[:rspec_reports].nil?
-    puts "Error: At least one of --test-reports or --rspec-reports must be provided"
-    exit 1
-  end
-
   artifacts = GitlabQuality::TestTooling::CodeCoverage::Artifacts.new(
     coverage_report: params[:coverage_report],
     test_map: params[:test_map],
-    test_reports: params[:test_reports],
-    rspec_reports: params[:rspec_reports]
+    test_reports: params[:test_reports]
   )
 
   coverage_report = artifacts.coverage_report
@@ -120,28 +109,24 @@ if params.any? && (required_params - params.keys).none?
 
   source_file_to_tests = GitlabQuality::TestTooling::CodeCoverage::TestMap.new(test_map).source_to_tests
 
-  # Process test reports using the new unified approach or fall back to legacy rspec_reports
-  tests_to_categories = if params[:test_reports]
-                          # Use new TestReport class for unified test reports
-                          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
-                        else
-                          # Fall back to legacy RspecReport for backward compatibility
-                          artifacts.rspec_reports.reduce({}) do |combined_hash, rspec_report_file|
-                            file_categories = GitlabQuality::TestTooling::CodeCoverage::RspecReport.new(rspec_report_file).tests_to_categories
-                            combined_hash.merge(file_categories) { |_, old_val, new_val| (old_val + new_val).uniq }
-                          end
-                        end
+  # 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
   )
 
   clickhouse_data = {

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,13 +11,13 @@ module GitlabQuality
       class Artifacts
         # Loads coverage artifacts from the filesystem
         #
-        # @param test_reports [String, nil] Glob pattern for test JSON report files (RSpec or Jest) (e.g., "reports/**/*.json")
-        # @param rspec_reports [String, nil] [DEPRECATED] Use test_reports instead. Glob pattern for RSpec JSON report files
+        # @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(coverage_report:, test_map:, test_reports: nil, rspec_reports: nil)
+        def initialize(coverage_report:, test_map:, test_reports:)
+          raise ArgumentError, "test_reports cannot be blank" if test_reports.blank?
+
           @test_reports_glob = test_reports
-          @rspec_reports_glob = rspec_reports
           @coverage_report_path = coverage_report
           @test_map_path = test_map
         end
@@ -33,19 +34,6 @@ module GitlabQuality
           end
         end
 
-        # Loads and parses RSpec JSON report files
-        #
-        # @deprecated Use {#test_reports} instead
-        # @return [Array<Hash>] Array of parsed JSON RSpec reports
-        # @raise [RuntimeError] If no RSpec reports are found or if JSON parsing fails
-        def rspec_reports
-          @rspec_report_files ||= rspec_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}"
-          end
-        end
-
         # Loads the LCOV coverage report file
         #
         # @return [String] Raw content of the LCOV coverage report
@@ -65,8 +53,6 @@ module GitlabQuality
         private
 
         def test_reports_paths
-          return [] if @test_reports_glob.nil? || @test_reports_glob.empty?
-
           @test_reports_paths ||= begin
             paths = Dir.glob(@test_reports_glob)
 
@@ -76,18 +62,6 @@ module GitlabQuality
           end
         end
 
-        def rspec_reports_paths
-          return [] if @rspec_reports_glob.nil? || @rspec_reports_glob.empty?
-
-          @rspec_reports_paths ||= begin
-            paths = Dir.glob(@rspec_reports_glob)
-
-            raise "No RSpec reports found matching pattern: #{@rspec_reports_glob}" if paths.empty?
-
-            paths
-          end
-        end
-
         def read_coverage_reports
           raise "Coverage report not found in: #{@coverage_report_path}" unless File.exist?(@coverage_report_path)
 

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/test_result/base_test_result.rb

@@ -8,7 +8,6 @@ module GitlabQuality
           "Net::ReadTimeout",
           "403 Forbidden - Your account has been blocked",
           "API failed (502) with `GitLab is not responding",
-          "Error Code: 502",
           "unexpected token at 'GitLab is not responding'",
           "GitLab: Internal API error (502).",
           "could not be found (502)",
@@ -128,26 +127,14 @@ module GitlabQuality
         end
 
         def full_stacktrace
-          page_error_failure = ""
-          first_non_ignored_failure = ""
-
           failures.each do |failure|
             message = failure['message'] || ""
             message_lines = failure['message_lines'] || []
 
             next if IGNORED_FAILURES.any? { |e| message.include?(e) }
 
-            formatted_failure = message_lines.empty? ? message : message_lines.join("\n")
-
-            if message.include?("PageErrorChecker")
-              page_error_failure = formatted_failure
-            elsif first_non_ignored_failure.empty?
-              first_non_ignored_failure = formatted_failure
-            end
+            return message_lines.empty? ? message : message_lines.join("\n")
           end
-
-          # Return PageErrorChecker failure if found, otherwise first non-ignored failure
-          page_error_failure.empty? ? first_non_ignored_failure : page_error_failure
         end
 
         def calls_shared_examples?

data/lib/gitlab_quality/test_tooling/version.rb

@@ -2,6 +2,6 @@
 
 module GitlabQuality
   module TestTooling
-    VERSION = "2.27.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.27.0
+  version: 3.0.0
 platform: ruby
 authors:
 - GitLab Quality
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-13 00:00:00.000000000 Z
+date: 2025-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -498,6 +498,7 @@ 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