gitlab_quality-test_tooling 3.0.0 → 3.5.0

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'table'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      module ClickHouse
+        class TestFileMappingsTable < GitlabQuality::TestTooling::CodeCoverage::ClickHouse::Table
+          TABLE_NAME = "test_file_mappings"
+
+          private
+
+          # @return [Boolean] True if the record is valid, false otherwise
+          def valid_record?(record)
+            valid_test_file?(record) && valid_source_file?(record)
+          end
+
+          # @return [Boolean] True if the test_file field is present
+          def valid_test_file?(record)
+            return true unless record[:test_file].blank?
+
+            logger.warn("#{LOG_PREFIX} Skipping record with nil/empty test_file: #{record}")
+            false
+          end
+
+          # @return [Boolean] True if the source_file field is present
+          def valid_source_file?(record)
+            return true unless record[:source_file].blank?
+
+            logger.warn("#{LOG_PREFIX} Skipping record with nil/empty source_file: #{record}")
+            false
+          end
+
+          # @return [Hash] Transformed mapping data including timestamp and CI metadata
+          def sanitized_data_record(record)
+            {
+              timestamp: time,
+              test_file: record[:test_file],
+              source_file: record[:source_file],
+              ci_project_path: ENV.fetch('CI_PROJECT_PATH', nil)
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,22 +4,31 @@ module GitlabQuality
   module TestTooling
     module CodeCoverage
       class CoverageData
+        RESPONSIBLE = 'responsible'
+        DEPENDENT = 'dependent'
+
         # @param [Hash<String, Hash>] code_coverage_by_source_file Source file
         #   mapped to test coverage data
         # @param [Hash<String, Array<String>>] source_file_to_tests Source files
         #   mapped to all test files testing them
-        # @param [Hash<String, Array<String>>] tests_to_categories Test files
+        # @param [Hash<String, Array<String>>] tests_to_feature_categories Test files
         #   mapped to all feature categories they belong to
-        # @param [Hash<String, Hash>] categories_to_teams Mapping of categories
+        # @param [Hash<String, Hash>] feature_categories_to_teams Mapping of feature categories
         #   to teams (i.e., groups, stages, sections)
         # @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 = {})
+        # @param [Hash<String, String>] test_classifications Mapping of test files
+        #   to their responsibility classification (responsible or dependent)
+        def initialize(
+          code_coverage_by_source_file, source_file_to_tests, tests_to_feature_categories,
+          feature_categories_to_teams, source_file_types = {}, test_classifications = {}
+        )
           @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
+          @tests_to_feature_categories = tests_to_feature_categories
+          @feature_categories_to_teams = feature_categories_to_teams
           @source_file_types = source_file_types
+          @test_classifications = test_classifications
         end
 
         # @return [Array<Hash<Symbol, String>>] Mapping of column name to row
@@ -32,7 +41,9 @@ module GitlabQuality
         #       branch_coverage: 95.0
         #       function_coverage: 100.0
         #       source_file_type: "backend"
-        #       category: "team_planning"
+        #       is_responsible: true
+        #       is_dependent: false
+        #       feature_category: "team_planning"
         #       group: "project_management"
         #       stage: "plan"
         #       section: "dev"
@@ -40,55 +51,81 @@ module GitlabQuality
         #     ...
         #   ]
         def as_db_table
-          all_files.flat_map do |file|
-            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?
-              base_data.merge(no_owner_info)
-            else
-              categories.map do |category|
-                base_data.merge(owner_info(category))
-              end
+          all_files.flat_map { |file| records_for_file(file) }
+        end
+
+        private
+
+        def records_for_file(file)
+          base_data = base_data_for(file)
+          feature_categories_with_flags = feature_categories_with_responsibility_flags_for(file)
+
+          if feature_categories_with_flags.empty?
+            base_data.merge(no_owner_info).merge(is_responsible: nil, is_dependent: nil)
+          else
+            feature_categories_with_flags.map do |feature_category, flags|
+              base_data.merge(owner_info(feature_category)).merge(
+                is_responsible: flags[:is_responsible],
+                is_dependent: flags[:is_dependent]
+              )
             end
           end
         end
 
-        private
+        def base_data_for(file)
+          coverage_data = @code_coverage_by_source_file[file]
+
+          {
+            file: file,
+            line_coverage: coverage_data&.dig(:percentage),
+            branch_coverage: coverage_data&.dig(:branch_percentage),
+            function_coverage: coverage_data&.dig(:function_percentage),
+            source_file_type: @source_file_types[file] || 'other'
+          }
+        end
 
         def no_owner_info
           {
-            category: nil,
+            feature_category: nil,
             group: nil,
             stage: nil,
             section: nil
           }
         end
 
-        def owner_info(category)
-          owner_info = @categories_to_teams[category]
+        def owner_info(feature_category)
+          owner_info = @feature_categories_to_teams[feature_category]
 
           {
-            category: category,
+            feature_category: feature_category,
             group: owner_info&.dig(:group),
             stage: owner_info&.dig(:stage),
             section: owner_info&.dig(:section)
           }
         end
 
-        def categories_for(file)
-          @source_file_to_tests[file]&.flat_map { |test_file| @tests_to_categories[test_file] || [] }&.uniq || []
+        # Returns a hash of feature_category => { is_responsible: bool, is_dependent: bool }
+        # for a given source file. A feature category can have both flags true if it has
+        # both unit tests (responsible) and integration/E2E tests (dependent).
+        def feature_categories_with_responsibility_flags_for(file)
+          test_files = @source_file_to_tests[file] || []
+          return {} if test_files.empty?
+
+          test_files.each_with_object({}) do |test_file, feature_category_to_flags|
+            feature_categories = @tests_to_feature_categories[test_file] || []
+            classification = @test_classifications[test_file]
+
+            feature_categories.each do |feature_category|
+              feature_category_to_flags[feature_category] ||= { is_responsible: false, is_dependent: false }
+
+              case classification
+              when RESPONSIBLE
+                feature_category_to_flags[feature_category][:is_responsible] = true
+              when DEPENDENT
+                feature_category_to_flags[feature_category][:is_dependent] = true
+              end
+            end
+          end
         end
 
         def all_files

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

@@ -85,7 +85,7 @@ module GitlabQuality
         end
 
         def register_source_file(filename)
-          @current_file = filename.gsub(%r{^\./}, '')
+          @current_file = normalize_path(filename)
           @parsed_content[@current_file] = {
             line_coverage: {},
             branch_coverage: {},
@@ -94,6 +94,16 @@ module GitlabQuality
           }
         end
 
+        def normalize_path(filename)
+          # Remove leading ./ if present
+          path = filename.gsub(%r{^\./}, '')
+
+          # Handle GDK/CI paths like "../../../home/gdk/gitlab-development-kit/gitlab/app/..."
+          # Extract path starting from known root directories
+          match = path.match(%r{((?:ee/)?(?:app|lib|config|db|spec|scripts|tooling|workhorse|vendor)/.+)$})
+          match ? match[1] : path
+        end
+
         def register_line_data(line_no, count)
           return unless @current_file
 

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class ResponsibilityClassifier
+        RESPONSIBLE = 'responsible'
+        DEPENDENT = 'dependent'
+
+        # @param test_to_sources [Hash<String, Array<String>>] Test files mapped to source files they cover
+        # @param responsible_patterns [Array<Regexp>] Patterns for unit tests
+        # @param dependent_patterns [Array<Regexp>] Patterns for integration/E2E tests
+        def initialize(test_to_sources, responsible_patterns:, dependent_patterns:)
+          @test_to_sources = test_to_sources
+          @responsible_patterns = responsible_patterns
+          @dependent_patterns = dependent_patterns
+        end
+
+        # Classifies each test file as responsible or dependent
+        # @return [Hash<String, String>] Test file path => classification
+        def classify_tests
+          @test_to_sources.keys.each_with_object({}) do |test_file, result|
+            result[test_file] = classify_test(test_file)
+          end
+        end
+
+        private
+
+        # Classifies a test file as responsible (unit) or dependent (integration/E2E).
+        #
+        # Dependent patterns are checked first because it's the safer default:
+        # - is_responsible: true claims "this file has unit test coverage"
+        # - is_dependent: true claims "this file has integration test coverage"
+        #
+        # If uncertain (overlapping patterns or no match), we default to dependent
+        # to avoid incorrectly inflating unit test coverage metrics.
+        def classify_test(test_file)
+          return DEPENDENT if @dependent_patterns.any? { |p| test_file.match?(p) }
+          return RESPONSIBLE if @responsible_patterns.any? { |p| test_file.match?(p) }
+
+          # Default to dependent for unknown test types
+          DEPENDENT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class ResponsibilityPatternsConfig
+        ConfigError = Class.new(StandardError)
+
+        attr_reader :responsible_patterns, :dependent_patterns
+
+        # @param file_path [String] Path to YAML config file
+        # @raise [ConfigError] if file cannot be loaded or parsed
+        def initialize(file_path)
+          @file_path = file_path
+          @config = load_config
+          @responsible_patterns = parse_patterns('responsible')
+          @dependent_patterns = parse_patterns('dependent')
+        end
+
+        private
+
+        def load_config
+          YAML.load_file(@file_path)
+        rescue Errno::ENOENT
+          raise ConfigError, "Config file not found: #{@file_path}"
+        rescue Psych::SyntaxError => e
+          raise ConfigError, "Invalid YAML syntax in #{@file_path}: #{e.message}"
+        end
+
+        def parse_patterns(key)
+          patterns = @config[key]
+
+          raise ConfigError, "Missing or invalid '#{key}' key in #{@file_path}. Expected an array of patterns." unless patterns.is_a?(Array)
+
+          patterns.map do |pattern|
+            Regexp.new(pattern)
+          rescue RegexpError => e
+            raise ConfigError, "Invalid regex pattern '#{pattern}' in #{@file_path}: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class TestFileMappingData
+        # @param [Hash<String, Array<String>>] test_to_sources Test files
+        #   mapped to all source files they cover
+        def initialize(test_to_sources)
+          @test_to_sources = test_to_sources
+        end
+
+        # @return [Array<Hash<Symbol, String>>] Mapping data formatted for database insertion
+        # @example Return value
+        #   [
+        #     { test_file: "spec/models/user_spec.rb", source_file: "app/models/user.rb" },
+        #     { test_file: "spec/models/user_spec.rb", source_file: "lib/utils.rb" },
+        #     ...
+        #   ]
+        def as_db_table
+          @test_to_sources.flat_map do |test_file, source_files|
+            source_files.map do |source_file|
+              {
+                test_file: test_file,
+                source_file: source_file
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'erb'
-
 module GitlabQuality
   module TestTooling
     module Report
@@ -68,12 +66,12 @@ module GitlabQuality
         end
 
         def execution_graph_section(test)
-          formatted_title = ERB::Util.url_encode(test.name)
+          formatted_path = CGI.escape(test.relative_file)
 
           <<~MKDOWN.strip
             ### Executions
 
-            [Spec metrics on all environments](https://dashboards.quality.gitlab.net/d/cW0UMgv7k/single-spec-metrics?orgId=1&var-run_type=All&var-name=#{formatted_title})
+            [Spec metrics on all environments](https://dashboards.devex.gitlab.net/d/739c1bdd-a436-452b-bddc-fccb4d055768/single-test-overview?var-file_path=#{formatted_path})
           MKDOWN
         end
 

data/lib/gitlab_quality/test_tooling/runtime/env.rb

@@ -103,6 +103,10 @@ module GitlabQuality
           "#{ci_project_name}-#{test_subset}"
         end
 
+        def quarantine_disabled?
+          enabled?(ENV.fetch('GLCI_DISABLE_QUARANTINE', nil), default: false)
+        end
+
         private
 
         def enabled?(value, default: true)

data/lib/gitlab_quality/test_tooling/test_meta/processor/meta_processor.rb

@@ -45,7 +45,7 @@ module GitlabQuality
               commits.each_with_index.map do |(changed_line_number, spec), index|
                 <<~MARKDOWN
                   #{index + 1}. [`#{spec['name']}`](https://gitlab.com/#{context.project}/-/blob/#{context.ref}/#{spec['file_path']}#L#{changed_line_number.to_i + 1})
-                      | [Testcase](#{spec['testcase']}) | [Spec metrics](#{context.single_spec_metrics_link(spec['name'])})
+                      | [Testcase](#{spec['testcase']}) | [Spec metrics](#{context.single_spec_metrics_link(spec['file_path'])})
                       #{failure_issue_text(spec)}
                 MARKDOWN
               end.join("\n")

data/lib/gitlab_quality/test_tooling/test_meta/test_meta_updater.rb

@@ -348,11 +348,11 @@ module GitlabQuality
 
         # Returns the link to the Grafana dashboard for single spec metrics
         #
-        # @param [String] example_name the full example name
+        # @param [String] file_path the full path of spec
         # @return [String]
-        def single_spec_metrics_link(example_name)
-          base_url = "https://dashboards.quality.gitlab.net/d/cW0UMgv7k/single-spec-metrics?orgId=1&var-run_type=All&var-name="
-          base_url + CGI.escape(example_name)
+        def single_spec_metrics_link(file_path)
+          base_url = "https://dashboards.devex.gitlab.net/d/739c1bdd-a436-452b-bddc-fccb4d055768/single-test-overview?var-file_path="
+          base_url + CGI.escape(file_path)
         end
 
         # Returns any test description string within single or double quotes

data/lib/gitlab_quality/test_tooling/test_metrics_exporter/config.rb

@@ -52,6 +52,7 @@ module GitlabQuality
           :skip_record_proc,
           :test_retried_proc,
           :custom_metrics_proc,
+          :spec_file_path_prefix,
           :logger
 
         # rubocop:disable Style/TrivialAccessors -- allows documenting that setting config enables the export as well as document input class type
@@ -108,6 +109,13 @@ module GitlabQuality
           @extra_rspec_metadata_keys ||= []
         end
 
+        # Extra path prefix for constructing full file path within mono-repository setups
+        #
+        # @return [String]
+        def spec_file_path_prefix
+          @spec_file_path_prefix ||= ""
+        end
+
         # A lambda that determines whether to skip recording a test result
         #
         # This is useful when you would want to skip initial failure when retrying specs is set up in a separate process

data/lib/gitlab_quality/test_tooling/test_metrics_exporter/test_metrics.rb

@@ -46,12 +46,16 @@ module GitlabQuality
             status: example.execution_result.status,
             run_time: (example.execution_result.run_time * 1000).round,
             location: example_location,
-            exception_class: exception_class,
+            # TODO: remove exception_class once migration to exception_classes is fully complete on clickhouse side
+            exception_class: example.execution_result.exception&.class&.to_s,
+            exception_classes: exception_classes.map { |e| e.class.to_s }.uniq,
             failure_exception: failure_exception,
             quarantined: quarantined?,
+            quarantine_issue_url: quarantine_issue_url || "",
             feature_category: example.metadata[:feature_category] || "",
             test_retried: config.test_retried_proc.call(example),
-            run_type: run_type
+            run_type: run_type,
+            spec_file_path_prefix: config.spec_file_path_prefix
           }
         end
 
@@ -95,6 +99,25 @@ module GitlabQuality
           example.execution_result.status == :pending
         end
 
+        # Extract quarantine issue URL from metadata
+        #
+        # @return [String, nil]
+        def quarantine_issue_url
+          return nil unless example.metadata.key?(:quarantine)
+
+          metadata = example.metadata[:quarantine]
+          case metadata
+          when String
+            # Direct URL: quarantine: 'https://gitlab.com/.../issues/123'
+            metadata if metadata.start_with?('http')
+          when Hash
+            # Hash format: quarantine: { issue: 'https://...', reason: '...' }
+            issue = metadata[:issue] || metadata['issue']
+            # Handle array of URLs (take the first one)
+            issue.is_a?(Array) ? issue.first : issue
+          end
+        end
+
         # Base ci job name
         #
         # @return [String]
@@ -127,22 +150,25 @@ module GitlabQuality
           @file_path ||= example_location.gsub(/:\d+$/, "")
         end
 
-        # Failure exception class
+        # Failure exception classes
         #
-        # @return [String]
-        def exception_class
-          example.execution_result.exception&.class&.to_s
+        # @return [Array<Exception>]
+        def exception_classes
+          exception = example.execution_result.exception
+          return [] unless exception
+          return [exception] unless exception.respond_to?(:all_exceptions)
+
+          exception.all_exceptions.flatten
         end
 
         # Truncated exception stacktrace
         #
         # @return [String]
         def failure_exception
-          example.execution_result.exception.then do |exception|
-            next unless exception
+          exception = example.execution_result.exception
+          return unless exception
 
-            exception.to_s.tr("\n", " ").slice(0, 1000)
-          end
+          exception.to_s.tr("\n", " ").slice(0, 1000)
         end
 
         # Test run type | suite name

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

@@ -65,6 +65,7 @@ module GitlabQuality
                 test_retried Bool,
                 feature_category LowCardinality(String) DEFAULT 'unknown',
                 run_type LowCardinality(String) DEFAULT 'unknown',
+                spec_file_path_prefix LowCardinality(String) DEFAULT '',
                 ci_project_id UInt32,
                 ci_job_name LowCardinality(String),
                 ci_job_id UInt64,
@@ -75,6 +76,7 @@ module GitlabQuality
                 ci_target_branch LowCardinality(String),
                 ci_server_url LowCardinality(String) DEFAULT 'https://gitlab.com',
                 exception_class String DEFAULT '',
+                exception_classes Array(String) DEFAULT [],
                 failure_exception String DEFAULT ''
             )
             ENGINE = MergeTree()

data/lib/gitlab_quality/test_tooling/test_quarantine/quarantine_formatter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rspec/core/formatters/base_formatter"
+
+module GitlabQuality
+  module TestTooling
+    module TestQuarantine
+      class QuarantineFormatter < ::RSpec::Core::Formatters::BaseFormatter
+        include QuarantineHelper
+
+        ::RSpec::Core::Formatters.register(
+          self,
+          :example_group_started,
+          :example_started
+        )
+
+        # Starts example group
+        # @param [RSpec::Core::Notifications::GroupNotification] example_group_notification
+        # @return [void]
+        def example_group_started(example_group_notification)
+          group = example_group_notification.group
+
+          skip_or_run_quarantined_tests_or_contexts(group)
+        end
+
+        # Starts example
+        # @param [RSpec::Core::Notifications::ExampleNotification] example_notification
+        # @return [void]
+        def example_started(example_notification)
+          example = example_notification.example
+
+          # if skip propagated from example_group, do not reset skip metadata
+          skip_or_run_quarantined_tests_or_contexts(example) unless example.metadata[:skip]
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/test_quarantine/quarantine_helper.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+
+module GitlabQuality
+  module TestTooling
+    module TestQuarantine
+      module QuarantineHelper
+        include ::RSpec::Core::Pending
+
+        extend self
+
+        # Skip tests in quarantine unless we explicitly focus on them or quarantine disabled
+        def skip_or_run_quarantined_tests_or_contexts(example)
+          return if Runtime::Env.quarantine_disabled?
+
+          if filters.key?(:quarantine)
+            included_filters = filters_other_than_quarantine
+
+            # If :quarantine is focused, skip the test/context unless its metadata
+            # includes quarantine and any other filters
+            # E.g., Suppose a test is tagged :smoke and :quarantine, and another is tagged
+            # :ldap and :quarantine. If we wanted to run just quarantined smoke tests
+            # using `--tag quarantine --tag smoke`, without this check we'd end up
+            # running that ldap test as well because of the :quarantine metadata.
+            # We could use an exclusion filter, but this way the test report will list
+            # the quarantined tests when they're not run so that we're aware of them
+            if should_skip_when_focused?(example.metadata, included_filters)
+              example.metadata[:skip] = "Only running tests tagged with :quarantine and any of #{included_filters.keys}"
+            end
+          elsif example.metadata.key?(:quarantine)
+            quarantine_tag = example.metadata[:quarantine]
+
+            example.metadata[:skip] = quarantine_message(quarantine_tag)
+          end
+        end
+
+        def filters_other_than_quarantine
+          filters.except(:quarantine)
+        end
+
+        def quarantine_message(quarantine_tag)
+          quarantine_message = %w[In quarantine]
+          quarantine_message << case quarantine_tag
+                                when String
+                                  ": #{quarantine_tag}"
+                                when Hash
+                                  quarantine_tag.key?(:issue) ? ": #{quarantine_tag[:issue]}" : ''
+                                else
+                                  ''
+                                end
+
+          quarantine_message.join(' ').strip
+        end
+
+        # Checks if a test or context should be skipped.
+        #
+        # Returns true if
+        # - the metadata does not includes the :quarantine tag
+        # or if
+        # - the metadata includes the :quarantine tag
+        # - and the filter includes other tags that aren't in the metadata
+        def should_skip_when_focused?(metadata, included_filters)
+          return true unless metadata.key?(:quarantine)
+          return false if included_filters.empty?
+
+          !metadata.keys.intersect?(included_filters.keys)
+        end
+
+        def filters
+          @filters ||= ::RSpec.configuration.inclusion_filter.rules
+        end
+      end
+    end
+  end
+end