Module: Henitai::ConfigurationValidator::Rules

Defined in:
lib/henitai/configuration_validator/rules.rb

Overview

Section-level validation rules.

Each validate_* method inspects one configuration section, warns about unknown keys via warn, and delegates leaf value checks to Scalars. Failures raise Henitai::ConfigurationError.

Class Method Summary collapse

Class Method Details

.configuration_error(message) ⇒ Object

Raises:



138
139
140
 
# File 'lib/henitai/configuration_validator/rules.rb', line 138

def configuration_error(message)
  raise Henitai::ConfigurationError, message
end

.ensure_hash!(value, path) ⇒ Object 



132
133
134
135
136
 
# File 'lib/henitai/configuration_validator/rules.rb', line 132

def ensure_hash!(value, path)
  return if value.is_a?(Hash)

  configuration_error("Invalid configuration value for #{path}: expected Hash, got #{value.class}")
end

.key_path(path, key) ⇒ Object 



128
129
130
 
# File 'lib/henitai/configuration_validator/rules.rb', line 128

def key_path(path, key)
  path ? "#{path}.#{key}" : key.to_s
end

.validate_all_logs(raw) ⇒ Object 



53
54
55
56
57
58
 
# File 'lib/henitai/configuration_validator/rules.rb', line 53

def validate_all_logs(raw)
  value = raw[:all_logs]
  return if value.nil?

  Scalars.validate_boolean(value, "all_logs")
end

.validate_coverage_criteria(raw) ⇒ Object 



92
93
94
95
96
97
98
99
 
# File 'lib/henitai/configuration_validator/rules.rb', line 92

def validate_coverage_criteria(raw)
  value = raw[:coverage_criteria]
  return if value.nil?

  ensure_hash!(value, "coverage_criteria")
  warn_unknown_keys(value, VALID_COVERAGE_CRITERIA_KEYS, "coverage_criteria")
  value.each { |key, flag| Scalars.validate_boolean(flag, "coverage_criteria.#{key}") }
end

.validate_dashboard(raw) ⇒ Object 



60
61
62
63
64
65
66
67
68
 
# File 'lib/henitai/configuration_validator/rules.rb', line 60

def validate_dashboard(raw)
  value = raw[:dashboard]
  return if value.nil?

  ensure_hash!(value, "dashboard")
  warn_unknown_keys(value, VALID_DASHBOARD_KEYS, "dashboard")
  Scalars.validate_optional_string(value[:project], "dashboard.project")
  Scalars.validate_optional_string(value[:base_url], "dashboard.base_url")
end

.validate_excludes(raw) ⇒ Object 



33
34
35
 
# File 'lib/henitai/configuration_validator/rules.rb', line 33

def validate_excludes(raw)
  Scalars.validate_string_array(raw[:excludes], "excludes")
end

.validate_includes(raw) ⇒ Object 



29
30
31
 
# File 'lib/henitai/configuration_validator/rules.rb', line 29

def validate_includes(raw)
  Scalars.validate_string_array(raw[:includes], "includes")
end

.validate_integration(raw) ⇒ Object 



19
20
21
22
23
24
25
26
27
 
# File 'lib/henitai/configuration_validator/rules.rb', line 19

def validate_integration(raw)
  value = raw[:integration]
  return if value.nil?
  return if value.is_a?(String)

  ensure_hash!(value, "integration")
  warn_unknown_keys(value, VALID_INTEGRATION_KEYS, "integration")
  Scalars.validate_optional_string(value[:name], "integration.name")
end

.validate_jobs(raw) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/henitai/configuration_validator/rules.rb', line 37

def validate_jobs(raw)
  value = raw[:jobs]
  return if value.nil?
  return if value.is_a?(Integer)

  configuration_error("Invalid configuration value for jobs: expected Integer, got #{value.class}")
end

.validate_mutation(raw) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/henitai/configuration_validator/rules.rb', line 70

def validate_mutation(raw)
  value = raw[:mutation]
  return if value.nil?

  ensure_hash!(value, "mutation")
  warn_unknown_keys(value, VALID_MUTATION_KEYS, "mutation")
  Scalars.validate_operator(value[:operators])
  validate_mutation_limits(value)
  validate_mutation_filters(value)
  validate_sampling(value[:sampling])
end

.validate_mutation_filters(value) ⇒ Object 



87
88
89
90
 
# File 'lib/henitai/configuration_validator/rules.rb', line 87

def validate_mutation_filters(value)
  Scalars.validate_string_array(value[:ignore_patterns], "mutation.ignore_patterns")
  Scalars.validate_ignore_patterns(value[:ignore_patterns])
end

.validate_mutation_limits(value) ⇒ Object 



82
83
84
85
 
# File 'lib/henitai/configuration_validator/rules.rb', line 82

def validate_mutation_limits(value)
  Scalars.validate_timeout(value[:timeout])
  Scalars.validate_max_flaky_retries(value[:max_flaky_retries])
end

.validate_reporters(raw) ⇒ Object 



45
46
47
 
# File 'lib/henitai/configuration_validator/rules.rb', line 45

def validate_reporters(raw)
  Scalars.validate_string_array(raw[:reporters], "reporters")
end

.validate_reports_dir(raw) ⇒ Object 



49
50
51
 
# File 'lib/henitai/configuration_validator/rules.rb', line 49

def validate_reports_dir(raw)
  Scalars.validate_optional_string(raw[:reports_dir], "reports_dir")
end

.validate_sampling(value) ⇒ Object 



110
111
112
113
114
115
116
117
118
 
# File 'lib/henitai/configuration_validator/rules.rb', line 110

def validate_sampling(value)
  return if value.nil?

  ensure_hash!(value, "mutation.sampling")
  warn_unknown_keys(value, VALID_SAMPLING_KEYS, "mutation.sampling")
  Scalars.validate_sampling_completeness(value)
  Scalars.validate_sampling_ratio(value[:ratio])
  Scalars.validate_sampling_strategy(value[:strategy])
end

.validate_thresholds(raw) ⇒ Object 



101
102
103
104
105
106
107
108
 
# File 'lib/henitai/configuration_validator/rules.rb', line 101

def validate_thresholds(raw)
  value = raw[:thresholds]
  return if value.nil?

  ensure_hash!(value, "thresholds")
  warn_unknown_keys(value, VALID_THRESHOLDS_KEYS, "thresholds")
  value.each { |key, threshold| Scalars.validate_threshold(threshold, "thresholds.#{key}") }
end

.validate_top_level_keys(raw) ⇒ Object 



15
16
17
 
# File 'lib/henitai/configuration_validator/rules.rb', line 15

def validate_top_level_keys(raw)
  warn_unknown_keys(raw, VALID_TOP_LEVEL_KEYS)
end

.warn_unknown_keys(raw, allowed_keys, path = nil) ⇒ Object 



120
121
122
123
124
125
126
 
# File 'lib/henitai/configuration_validator/rules.rb', line 120

def warn_unknown_keys(raw, allowed_keys, path = nil)
  raw.each_key do |key|
    next if allowed_keys.include?(key)

    ConfigurationValidator.warn "Unknown configuration key: #{key_path(path, key)}"
  end
end