gitlab_quality-test_tooling 3.0.0 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f037a73b3fd4a445324a37084915ea2d020475cca6f4e3b1d23045f290351082
-  data.tar.gz: e32bc045856df09004e725b9b84317c74ffb66b59ed640b078e292f46a3ff565
+  metadata.gz: 3cb2e6580b8b15e78116b52ffd4fed91e0ab7db14ce914eb90f34ace0ca84741
+  data.tar.gz: 14c55d5e6048c27a891dded80da8d23c3c3b71df15b04c8ff1c98404643bb19e
 SHA512:
-  metadata.gz: 400c1e51bf57a3f10cdb36c083444153326da8710edd828839881867aed4d9282da4b21fa16357f49bb498ac48199dda888e422e1ddf4f5453769cb5bdc92211
-  data.tar.gz: cc071d0ca3c54a0d3408f6fc91165348c403ab5109c473d7bc518701a17f90d992f02139614dfb99fd53cac7e0ffef688241c7c232cf373344269ffe3e8b4436
+  metadata.gz: 607a792c6df20d566ab3ec3dba96b80ed8ae8c08c6c6fe30ab9cbc39ccc2201c0934b86641ff137a2b9726d2b3386ef0ed22cb76f160faeacd74aef91c4007a8
+  data.tar.gz: 39d357544ea50bbc8968a224b699110f6957774140e7c8074fa9f28a5cd1cf03b1cdb6f0f0e22fd9a2b97ad06b0d54d183d06db043ff52a048a30758e928294f

data/Gemfile.lock

@@ -1,13 +1,12 @@
 PATH
   remote: .
   specs:
-    gitlab_quality-test_tooling (3.0.0)
-      activesupport (>= 7.0, < 7.3)
+    gitlab_quality-test_tooling (3.7.0)
+      activesupport (>= 7.0)
       amatch (~> 0.4.1)
       fog-google (~> 1.24, >= 1.24.1)
       gitlab (>= 4.19, < 7.0)
       http (~> 5.0)
-      influxdb-client (~> 3.1)
       nokogiri (~> 1.10)
       parallel (>= 1, < 2)
       rainbow (>= 3, < 4)
@@ -200,7 +199,6 @@ GEM
     httpclient (2.8.3)
     i18n (1.14.6)
       concurrent-ruby (~> 1.0)
-    influxdb-client (3.1.0)
     jaro_winkler (1.6.0)
     json (2.7.2)
     jwt (2.9.3)

data/README.md

@@ -185,20 +185,6 @@ Usage: exe/failed-test-issues [options]
     -h, --help                       Show the usage
 ```
 
-### `exe/existing-test-health-issue`
-
-```shell
-Purpose: Checks whether tests coming from the rspec JSON report files has an existing test health issue opened.
-Usage: exe/existing-test-health-issue [options]
-    -i, --input-files INPUT_FILES    JSON rspec-retry report files
-    -p, --project PROJECT            Can be an integer or a group/project string
-    -t, --token TOKEN                A valid access token with `api` scope and Maintainer permission in PROJECT
-        --health-problem-type PROBLEM_TYPE
-                                     Look for the given health problem type (failures, pass-after-retry, slow)
-    -v, --version                    Show the version
-    -h, --help                       Show the usage
-```
-
 ### `exe/detect-infrastructure-failures`
 
 ```shell
@@ -290,6 +276,53 @@ Usage: exe/feature-readiness-evaluation [options]
     -h, --help                       Show the usage
 ```
 
+### `exe/test-coverage`
+
+```shell
+Purpose: Export test coverage metrics to ClickHouse
+Usage: exe/test-coverage [options]
+
+Options:
+        --test-reports GLOB          Glob pattern for test JSON reports (RSpec or Jest) (e.g., "reports/**/*.json")
+        --coverage-report PATH       Path to the LCOV coverage report (e.g., "coverage/lcov/gitlab.lcov")
+        --test-map PATH              Path to the test map file (e.g., "crystalball/packed-mapping.json.gz")
+        --clickhouse-url URL         ClickHouse server URL
+        --clickhouse-database DATABASE
+                                     ClickHouse database name
+        --clickhouse-username USERNAME
+                                     ClickHouse username
+        --clickhouse-shared-database DATABASE
+                                     ClickHouse shared database name
+        --responsibility-patterns PATH
+                                     Path to YAML file with responsibility classification patterns
+
+Environment variables:
+  GLCI_CLICKHOUSE_METRICS_PASSWORD   ClickHouse password (required, not passed via CLI for security)
+
+    -h, --help                       Show the usage
+    -v, --version                    Show the version
+```
+
+### `exe/sync-category-owners`
+
+```shell
+Purpose: Sync feature category ownership data from stages.yml to ClickHouse
+Usage: exe/sync-category-owners [options]
+
+Options:
+        --clickhouse-url URL         ClickHouse server URL
+        --clickhouse-database DATABASE
+                                     ClickHouse database name
+        --clickhouse-username USERNAME
+                                     ClickHouse username
+
+Environment variables:
+  GLCI_CLICKHOUSE_METRICS_PASSWORD   ClickHouse password (required)
+
+    -h, --help                       Show the usage
+    -v, --version                    Show the version
+```
+
 ## Development
 
 ### Initial setup

data/exe/sync-category-owners

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "uri"
+
+require_relative "../lib/gitlab_quality/test_tooling"
+
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/category_owners'
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/click_house/category_owners_table'
+
+params = {}
+required_params = [:clickhouse_url, :clickhouse_database, :clickhouse_username]
+
+options = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+  opts.separator ""
+  opts.separator "Syncs feature category ownership data from stages.yml to ClickHouse."
+  opts.separator ""
+  opts.separator "Options:"
+
+  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)"
+  opts.separator ""
+
+  opts.on('-h', '--help', 'Show the usage') do
+    puts opts
+    exit
+  end
+
+  opts.on_tail('-v', '--version', 'Show the version') do
+    require_relative "../lib/gitlab_quality/test_tooling/version"
+    puts "#{$PROGRAM_NAME} : #{GitlabQuality::TestTooling::VERSION}"
+    exit
+  end
+
+  opts.parse(ARGV)
+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
+
+  category_owners = GitlabQuality::TestTooling::CodeCoverage::CategoryOwners.new
+
+  category_owners_table = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::CategoryOwnersTable.new(
+    url: params[:clickhouse_url],
+    database: params[:clickhouse_database],
+    username: params[:clickhouse_username],
+    password: clickhouse_password
+  )
+
+  category_owners_table.push(category_owners.as_db_table)
+
+  puts "Successfully synced feature category ownership data to ClickHouse"
+else
+  puts "Missing argument(s). Required arguments are: #{required_params.map { |p| "--#{p.to_s.tr('_', '-')}" }.join(', ')}"
+  puts options
+  exit 1
+end

data/exe/test-coverage

@@ -3,21 +3,26 @@
 
 require "optparse"
 require "uri"
+require "yaml"
 
 require_relative "../lib/gitlab_quality/test_tooling"
 
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/category_owners'
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/click_house/category_owners_table'
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/click_house/coverage_metrics_table'
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/click_house/test_file_mappings_table'
 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/test_report'
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/test_map'
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/test_file_mapping_data'
 require_relative '../lib/gitlab_quality/test_tooling/code_coverage/source_file_classifier'
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/responsibility_classifier'
+require_relative '../lib/gitlab_quality/test_tooling/code_coverage/responsibility_patterns_config'
 
 params = {}
-required_params = [:test_reports, :coverage_report, :test_map, :clickhouse_url, :clickhouse_database, :clickhouse_username]
+required_params = [:test_reports, :coverage_report, :test_map, :clickhouse_url, :clickhouse_database, :clickhouse_username, :clickhouse_shared_database, :responsibility_patterns]
 
 options = OptionParser.new do |opts|
   opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
@@ -50,6 +55,14 @@ options = OptionParser.new do |opts|
     params[:clickhouse_username] = username
   end
 
+  opts.on('--clickhouse-shared-database DATABASE', 'ClickHouse shared database name') do |database|
+    params[:clickhouse_shared_database] = database
+  end
+
+  opts.on('--responsibility-patterns PATH', 'Path to YAML file with responsibility classification patterns') do |path|
+    params[:responsibility_patterns] = path
+  end
+
   opts.separator ""
   opts.separator "Environment variables:"
   opts.separator "  GLCI_CLICKHOUSE_METRICS_PASSWORD   ClickHouse password (required, not passed via CLI for security)"
@@ -78,7 +91,7 @@ if params.any? && (required_params - params.keys).none?
     exit 1
   end
 
-  [:clickhouse_url, :clickhouse_database, :clickhouse_username].each do |param|
+  [:clickhouse_url, :clickhouse_database, :clickhouse_username, :clickhouse_shared_database].each do |param|
     if params[param].to_s.strip.empty?
       puts "Error: --#{param.to_s.tr('_', '-')} cannot be empty"
       exit 1
@@ -107,7 +120,9 @@ if params.any? && (required_params - params.keys).none?
 
   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
+  test_map_parser = GitlabQuality::TestTooling::CodeCoverage::TestMap.new(test_map)
+  source_file_to_tests = test_map_parser.source_to_tests
+  test_to_sources = test_map_parser.test_to_sources
 
   # Process test reports
   tests_to_categories = artifacts.test_reports.reduce({}) do |combined_hash, test_report_file|
@@ -121,12 +136,31 @@ if params.any? && (required_params - params.keys).none?
   source_file_classifier = GitlabQuality::TestTooling::CodeCoverage::SourceFileClassifier.new
   source_file_types = source_file_classifier.classify(code_coverage_by_source_file.keys)
 
+  # Load responsibility patterns from config file
+  begin
+    patterns_config = GitlabQuality::TestTooling::CodeCoverage::ResponsibilityPatternsConfig.new(
+      params[:responsibility_patterns]
+    )
+  rescue GitlabQuality::TestTooling::CodeCoverage::ResponsibilityPatternsConfig::ConfigError => e
+    puts "Error: #{e.message}"
+    exit 1
+  end
+
+  # Classify test files as responsible or dependent
+  responsibility_classifier = GitlabQuality::TestTooling::CodeCoverage::ResponsibilityClassifier.new(
+    test_to_sources,
+    responsible_patterns: patterns_config.responsible_patterns,
+    dependent_patterns: patterns_config.dependent_patterns
+  )
+  test_classifications = responsibility_classifier.classify_tests
+
   coverage_data = GitlabQuality::TestTooling::CodeCoverage::CoverageData.new(
     code_coverage_by_source_file,
     source_file_to_tests,
     tests_to_categories,
-    category_owners.categories_to_teams,
-    source_file_types
+    category_owners.feature_categories_to_teams,
+    source_file_types,
+    test_classifications
   )
 
   clickhouse_data = {
@@ -136,18 +170,28 @@ if params.any? && (required_params - params.keys).none?
     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.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
+  shared_clickhouse_data = {
+    url: params[:clickhouse_url],
+    database: params[:clickhouse_shared_database],
+    username: params[:clickhouse_username],
+    password: clickhouse_password
+  }
 
+  category_owners_table  = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::CategoryOwnersTable.new(**shared_clickhouse_data)
+  coverage_metrics_table = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::CoverageMetricsTable.new(
+    category_owners_table: category_owners_table,
+    **clickhouse_data
+  )
   coverage_metrics_table.push(coverage_data.as_db_table)
+
+  # Export test-to-file mappings
+  test_file_mapping_data = GitlabQuality::TestTooling::CodeCoverage::TestFileMappingData.new(
+    test_to_sources,
+    tests_to_categories: tests_to_categories,
+    feature_categories_to_teams: category_owners.feature_categories_to_teams
+  )
+  test_file_mappings_table = GitlabQuality::TestTooling::CodeCoverage::ClickHouse::TestFileMappingsTable.new(**shared_clickhouse_data)
+  test_file_mappings_table.push(test_file_mapping_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/README.md

@@ -0,0 +1,162 @@
+# Code Coverage Module
+
+Exports test coverage data to ClickHouse, enriched with:
+
+- **Feature category ownership** - group, stage, and section for each covered file
+- **Responsibility classification** - whether coverage comes from unit or integration tests
+- **Test-to-file mappings** - which source files each test covers
+
+## How It Works
+
+### Feature Category Attribution
+
+Coverage data is enriched with feature category ownership by joining three data sources:
+
+1. **Coverage Report** (LCOV) - which source files have coverage and their percentages
+2. **Test Map** - which test files cover each source file
+3. **Test Reports** (JSON) - which feature category each test file belongs to
+
+```mermaid
+flowchart LR
+    subgraph Inputs
+        A["<b>Coverage Report</b><br/>user.rb: 85%"]
+        B["<b>Test Map</b><br/>user.rb → user_spec.rb"]
+        C["<b>Test Reports</b><br/>user_spec.rb → user_profile"]
+    end
+
+    subgraph Output
+        E["<b>ClickHouse Record</b><br/>file: user.rb<br/>feature_category: user_profile<br/>coverage: 85%"]
+    end
+
+    A --> D((Join))
+    B --> D
+    C --> D
+    D --> E
+```
+
+This enables **multi-category attribution**: if a source file is covered by tests from
+multiple feature categories, it creates a separate record for each category in ClickHouse.
+
+### Why All Three Inputs Are Required
+
+| Input | Provides | Without it |
+|-------|----------|------------|
+| Coverage Report | Line/branch coverage percentages | No coverage metrics |
+| Test Map | Source file → test file relationships | No feature category attribution (all records have `category=NULL`) |
+| Test Reports | Test file → feature category metadata | No feature category attribution (all records have `category=NULL`) |
+
+## Responsibility Classification
+
+Tests are classified as either **responsible** or **dependent**:
+
+- **Responsible**: Unit tests that directly test a component in isolation
+- **Dependent**: Integration/E2E tests that exercise a component through other layers
+
+This classification is tracked per (source_file, feature_category) combination using two boolean columns:
+
+| is_responsible | is_dependent | Meaning |
+|----------------|--------------|---------|
+| `true` | `true` | Source file has both unit AND integration test coverage from this feature category |
+| `true` | `false` | Source file has only unit test coverage from this feature category |
+| `false` | `true` | Source file has only integration test coverage from this feature category |
+| `nil` | `nil` | No test mapping exists for this source file |
+
+### Configuration
+
+This gem is designed to be reusable across different projects. Classification patterns
+are project-specific and must be provided via a YAML config file, since different
+codebases have different test directory structures. The config file defines regex
+patterns for matching test file paths:
+
+> **Note:** The table above describes the *semantic meaning* of the flags. The patterns
+> you configure determine *which tests* produce those flags for your project.
+
+```yaml
+# responsibility_patterns.yml
+responsible:
+  - "^spec/(models|controllers|services)/"   # Backend unit tests
+  - "^spec/frontend/"                        # Frontend unit tests
+  - "_test\\.go$"                            # Go unit tests
+
+dependent:
+  - "^spec/(requests|features|integration)/" # Backend integration tests
+  - "^spec/frontend_integration/"            # Frontend integration tests
+  - "^qa/"                                   # E2E tests
+  - "_integration_test\\.go$"                # Go integration tests
+```
+
+**Pattern matching rules:**
+1. Dependent patterns are checked first (higher priority)
+2. If no pattern matches, the test defaults to "dependent"
+3. Patterns are Ruby regexes (escape special characters like `.` with `\\`)
+
+**Why dependent has priority:** We use a conservative approach. `is_responsible: true`
+makes a stronger claim ("this file has unit test coverage") than `is_dependent: true`.
+If a test matches both patterns or no patterns, defaulting to "dependent" avoids
+incorrectly inflating unit test coverage metrics. It's safer to under-claim than over-claim.
+
+### Example: GitLab Configuration
+
+```yaml
+# .gitlab/coverage/responsibility_patterns.yml
+responsible:
+  # Backend unit test directories
+  - "^spec/(models|controllers|services|workers|helpers|mailers|policies|presenters|uploaders|validators|lib|graphql|serializers|components)/"
+  - "^ee/spec/(models|controllers|services|workers|helpers|mailers|policies|presenters|uploaders|validators|lib|graphql|serializers|components)/"
+  # Frontend unit tests
+  - "^spec/frontend/"
+  - "^ee/spec/frontend/"
+  # Go unit tests
+  - "_test\\.go$"
+
+dependent:
+  # Backend integration tests
+  - "^spec/(requests|features|system|integration)/"
+  - "^ee/spec/(requests|features|system|integration)/"
+  # Frontend integration tests
+  - "^spec/frontend_integration/"
+  - "^ee/spec/frontend_integration/"
+  # E2E tests
+  - "^qa/"
+  # Go integration tests
+  - "_integration_test\\.go$"
+```
+
+### Example: Standard Rails Project
+
+```yaml
+# config/responsibility_patterns.yml
+responsible:
+  - "^test/(models|controllers|services|helpers|mailers)/"
+  - "^test/unit/"
+
+dependent:
+  - "^test/(integration|system)/"
+  - "^spec/features/"
+```
+
+## Test-to-File Mappings
+
+When a test map is provided, the module also exports test-to-source-file relationships
+to a separate `test_file_mappings` table. This enables:
+
+- **Coverage context for tests** - see which source files a specific test covers
+- **Impact analysis** - understand which files would lose coverage if a test is quarantined
+- **Flaky test triage** - correlate flaky tests with the source files they cover
+
+## CLI
+
+Example usage:
+
+```bash
+test-coverage \
+  --test-reports 'rspec/*.json' \
+  --coverage-report 'coverage/lcov.info' \
+  --test-map 'mapping.json' \
+  --responsibility-patterns 'config/responsibility_patterns.yml' \
+  --clickhouse-url 'https://clickhouse.example.com' \
+  --clickhouse-database 'coverage' \
+  --clickhouse-username 'user'
+```
+
+See `exe/test-coverage --help` for full usage.

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

@@ -11,7 +11,8 @@ module GitlabQuality
       class Artifacts
         # Loads coverage artifacts from the filesystem
         #
-        # @param test_reports [String] Glob pattern for test JSON report files (RSpec or Jest) (e.g., "reports/**/*.json")
+        # @param test_reports [String] Glob pattern(s) for test JSON report files (RSpec or Jest).
+        #   Supports comma-separated patterns (e.g., "jest/**/*.json,rspec/**/*.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:)
@@ -54,7 +55,9 @@ module GitlabQuality
 
         def test_reports_paths
           @test_reports_paths ||= begin
-            paths = Dir.glob(@test_reports_glob)
+            # Support comma-separated glob patterns (e.g., "jest/**/*.json,rspec/**/*.json")
+            patterns = @test_reports_glob.split(',').map(&:strip).reject(&:empty?)
+            paths = Dir.glob(patterns)
 
             raise "No test reports found matching pattern: #{@test_reports_glob}" if paths.empty?
 

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

@@ -15,17 +15,17 @@ module GitlabQuality
         BASE_DELAY  = 1 # seconds
         MAX_RETRIES = 3
 
-        # @return [Hash] Category ownership hierarchy, section -> stage -> group -> [categories]
+        # @return [Hash] Feature category ownership hierarchy, section -> stage -> group -> [feature_categories]
         # @example Return value
         #   {
         #     "team_planning" => {             # section
         #       "project_management" => {      # stage
         #         "plan" => [                  # group
-        #           "dev",                     # category
-        #           "service_desk"             # category
+        #           "dev",                     # feature_category
+        #           "service_desk"             # feature_category
         #         ],
         #         "product_planning" => [      # group
-        #           "portfolio_management",    # category
+        #           "portfolio_management",    # feature_category
         #           ...
         #         ]
         #       }
@@ -35,7 +35,7 @@ module GitlabQuality
         attr_reader :hierarchy
 
         def initialize
-          @categories_map = {}
+          @feature_categories_map = {}
           @hierarchy = {}
 
           yaml_file = fetch_yaml_file
@@ -43,12 +43,12 @@ module GitlabQuality
           populate_ownership_hierarchy(yaml_content)
         end
 
-        # @return [Array<Hash>] Flattened category ownership
+        # @return [Array<Hash>] Flattened feature category ownership
         # @example Return value
         #   [
-        #     { category: "team_planning", group: "project_management", stage: "plan", section: "dev" },
-        #     { category: "service_desk", group: "project_management", stage: "plan", section: "dev" },
-        #     { category: "portfolio_management", group: "product_planning", stage: "plan", section: "dev" }
+        #     { feature_category: "team_planning", group: "project_management", stage: "plan", section: "dev" },
+        #     { feature_category: "service_desk", group: "project_management", stage: "plan", section: "dev" },
+        #     { feature_category: "portfolio_management", group: "product_planning", stage: "plan", section: "dev" }
         #     ...
         #   ]
         def as_db_table
@@ -58,10 +58,10 @@ module GitlabQuality
             stages.each do |stage, groups|
               next unless groups
 
-              groups.each do |group, categories|
-                Array(categories).each do |category|
+              groups.each do |group, feature_categories|
+                Array(feature_categories).each do |feature_category|
                   flattened_hierarchy << {
-                    category: category,
+                    feature_category: feature_category,
                     group: group,
                     stage: stage,
                     section: section
@@ -72,7 +72,7 @@ module GitlabQuality
           end
         end
 
-        # @return [Hash] Mapping of categories to teams (i.e., groups, stages, sections)
+        # @return [Hash] Mapping of feature categories to teams (i.e., groups, stages, sections)
         # @example Return value
         #   {
         #     "team_planning" => { group: "project_management", stage: "plan", section: "dev" },
@@ -80,9 +80,9 @@ module GitlabQuality
         #     "portfolio_management" => { group: "product_planning", stage: "plan", section: "dev" },
         #     ...
         #   }
-        def categories_to_teams
-          populate_categories_map(hierarchy)
-          @categories_map
+        def feature_categories_to_teams
+          populate_feature_categories_map(hierarchy)
+          @feature_categories_map
         end
 
         private
@@ -116,35 +116,39 @@ module GitlabQuality
             groups = stage_data['groups'] || {}
             next unless section
 
-            groups.each { |group, group_data| add_hierarchy_entry(section, stage, group, group_data['categories']) }
+            groups.each do |group, group_data|
+              add_hierarchy_entry(section, stage, group, group_data['categories'])
+              add_hierarchy_entry(section, stage, group, group_data['maintained_categories'])
+            end
           end
         end
 
         def add_hierarchy_entry(section, stage, group, categories)
           @hierarchy[section] ||= {}
           @hierarchy[section][stage] ||= {}
-          @hierarchy[section][stage][group] = categories || []
+          @hierarchy[section][stage][group] ||= []
+          @hierarchy[section][stage][group].concat(Array(categories))
         end
 
-        def populate_categories_map(data, current_section = nil, current_stage = nil, current_group = nil)
+        def populate_feature_categories_map(data, current_section = nil, current_stage = nil, current_group = nil)
           case data
           when Hash # Sections / Stages / Groups
             data.each do |key, value|
               if current_section.nil? # Sections
-                populate_categories_map(value, key, nil, nil)
+                populate_feature_categories_map(value, key, nil, nil)
               elsif current_stage.nil? # Stages
-                populate_categories_map(value, current_section, key, nil)
+                populate_feature_categories_map(value, current_section, key, nil)
               elsif current_group.nil? # Groups
-                populate_categories_map(value, current_section, current_stage, key)
-              else                     # Categories
-                populate_categories_map(value, current_section, current_stage, current_group)
+                populate_feature_categories_map(value, current_section, current_stage, key)
+              else                     # Feature categories
+                populate_feature_categories_map(value, current_section, current_stage, current_group)
               end
             end
-          when Array # Categories array
-            data.each do |category|
-              next unless category.is_a?(String)
+          when Array # Feature categories array
+            data.each do |feature_category|
+              next unless feature_category.is_a?(String)
 
-              @categories_map[category] = {
+              @feature_categories_map[feature_category] = {
                 section: current_section,
                 stage: current_stage,
                 group: current_group