rsmp-validator 0.1.0 → 0.3.2

data/lib/rsmp/validator/compliance/config_metadata.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RSMP
+  module Validator
+    module Compliance
+      # Reads stable compliance target metadata from a validator YAML config file.
+      class ConfigMetadata
+        def initialize(path)
+          @path = path
+        end
+
+        def target
+          return {} unless @path && File.exist?(@path)
+
+          metadata = YAML.safe_load_file(@path, aliases: true)['compliance']
+          metadata.is_a?(Hash) ? stringify(metadata) : {}
+        rescue Psych::Exception
+          {}
+        end
+
+        private
+
+        def stringify(hash)
+          hash.transform_keys(&:to_s).transform_values { |value| value.is_a?(Hash) ? stringify(value) : value }
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/compliance/config_sxls.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RSMP
+  module Validator
+    module Compliance
+      # Formats resolved validator SXL config for compliance reports.
+      class ConfigSxls
+        def initialize(config)
+          @config = config
+        end
+
+        def to_h
+          Array(@config && @config['sxls']).each_with_object({}) do |sxl, memo|
+            next unless sxl.is_a?(Hash)
+
+            name = sxl['name']
+            version = sxl['version']
+            memo[name.to_s] = version.to_s if name && version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/compliance/report.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'time'
+require_relative 'report_failure'
+require_relative 'report_metadata'
+
+module RSMP
+  module Validator
+    module Compliance
+      # Builds the machine-readable compliance report emitted by rsmp-validator.
+      class Report
+        COMPLIANCE_SCHEMA_VERSION = 1
+
+        def initialize(assertions:, env: ENV, args: ARGV, generated_at: Time.now.utc, **options)
+          @assertions = assertions
+          @args = args
+          @generated_at = generated_at
+          @metadata = ReportMetadata.new(
+            env: env,
+            config: options[:config],
+            config_path: options[:config_path],
+            log_path: options[:log_path],
+            report_json_path: options[:report_json_path]
+          )
+        end
+
+        def self.write(path, **options)
+          report = new(**options).to_h
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, "#{JSON.pretty_generate(report)}\n")
+          report
+        end
+
+        def to_h
+          {
+            'schema_version' => COMPLIANCE_SCHEMA_VERSION,
+            'generated_at' => @generated_at.iso8601,
+            'target' => @metadata.target,
+            'workflow' => @metadata.workflow,
+            'run' => @metadata.run,
+            'matrix' => @metadata.matrix,
+            'summary' => summary,
+            'failures' => failures
+          }
+        end
+
+        private
+
+        def summary
+          {
+            'status' => @assertions.passed? ? 'passed' : 'failed',
+            'passed' => @assertions.passed?,
+            'test_count' => @assertions.total,
+            'passed_count' => @assertions.passed.size,
+            'failed_count' => @assertions.failed.size,
+            'errored_count' => @assertions.errored.size,
+            'skipped_count' => @assertions.skipped.size,
+            'assertion_count' => @assertions.count
+          }
+        end
+
+        def failures
+          @assertions.each_failure.map { |failure| ReportFailure.new(failure).to_h }
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/compliance/report_failure.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RSMP
+  module Validator
+    module Compliance
+      # Converts a failed Sus assertion/error into compact JSON-friendly data.
+      class ReportFailure
+        ANSI_ESCAPE = /\e\[[0-9;]*m/
+
+        def initialize(failure)
+          @failure = failure
+        end
+
+        def to_h
+          message = failure_message
+          {
+            'id' => failure_id,
+            'message' => clean_text(message[:text]),
+            'location' => message[:location],
+            'type' => @failure.class.name
+          }.compact
+        end
+
+        private
+
+        def failure_message
+          @failure.message
+        rescue StandardError => e
+          { text: e.message, location: failure_id }
+        end
+
+        def failure_id
+          identity = @failure.respond_to?(:identity) ? @failure.identity : nil
+          identity&.to_s
+        end
+
+        def clean_text(text)
+          return nil unless text
+
+          text.to_s.gsub(ANSI_ESCAPE, '').strip
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/compliance/report_metadata.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'config_metadata'
+require_relative 'config_sxls'
+
+module RSMP
+  module Validator
+    module Compliance
+      # Builds static and runtime metadata for a compliance report.
+      class ReportMetadata
+        def initialize(env:, config: nil, config_path: nil, log_path: nil, report_json_path: nil)
+          @env = env
+          @config = config
+          @config_path = config_path
+          @log_path = log_path
+          @report_json_path = report_json_path
+        end
+
+        def target
+          ConfigMetadata.new(config_path).target.merge(env_target_metadata)
+        end
+
+        def workflow
+          env_hash(
+            'name' => 'GITHUB_WORKFLOW',
+            'file' => 'COMPLIANCE_WORKFLOW_FILE',
+            'event' => 'GITHUB_EVENT_NAME',
+            'ref' => 'GITHUB_REF',
+            'sha' => 'GITHUB_SHA'
+          ).merge(workflow_file_from_ref)
+        end
+
+        def run
+          {
+            'id' => integer_env('GITHUB_RUN_ID'),
+            'number' => integer_env('GITHUB_RUN_NUMBER'),
+            'attempt' => integer_env('GITHUB_RUN_ATTEMPT'),
+            'url' => run_url,
+            'log_artifact' => env_value('COMPLIANCE_LOG_ARTIFACT') || @log_path,
+            'report_artifact' => env_value('COMPLIANCE_REPORT_ARTIFACT') || @report_json_path
+          }.compact
+        end
+
+        def matrix
+          values = {
+            'core' => config_value('core_version'),
+            'os' => env_value('RUNNER_OS')
+          }.compact
+          sxls = ConfigSxls.new(@config).to_h
+          values['sxls'] = sxls unless sxls.empty?
+          values
+        end
+
+        private
+
+        attr_reader :config_path
+
+        def env_target_metadata
+          env_hash(
+            'id' => 'COMPLIANCE_TARGET_ID',
+            'kind' => 'COMPLIANCE_TARGET_KIND',
+            'name' => 'COMPLIANCE_TARGET_NAME',
+            'product_url' => 'COMPLIANCE_PRODUCT_URL'
+          )
+        end
+
+        def workflow_file_from_ref
+          workflow_ref = env_value('GITHUB_WORKFLOW_REF')
+          match = workflow_ref&.match(%r{/(\.github/workflows/[^@]+)@})
+          match ? { 'file' => File.basename(match[1]) } : {}
+        end
+
+        def env_hash(mapping)
+          mapping.transform_values { |name| env_value(name) }.compact
+        end
+
+        def config_value(name)
+          @config[name] if @config.is_a?(Hash)
+        end
+
+        def integer_env(name)
+          value = env_value(name)
+          value&.to_i
+        end
+
+        def env_value(name)
+          value = @env[name]
+          value unless value.nil? || value == ''
+        end
+
+        def run_url
+          repository = env_value('GITHUB_REPOSITORY')
+          run_id = env_value('GITHUB_RUN_ID')
+          return nil unless repository && run_id
+
+          "https://github.com/#{repository}/actions/runs/#{run_id}"
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/config_check.rb

@@ -0,0 +1,72 @@
+require 'yaml'
+
+module RSMP
+  module Validator
+    # Validates rsmp-validator config files and their embedded RSMP node config.
+    class ConfigCheck
+      Result = Struct.new(:path, :mode, :options, keyword_init: true)
+
+      class << self
+        def check_file(path, mode: 'auto')
+          raw = load_file(path)
+          resolved_mode = resolve_mode(mode, raw)
+          options = options_class_for(resolved_mode).new(config_settings(raw), log_settings: raw['log'])
+
+          Result.new(path: path, mode: resolved_mode, options: options)
+        end
+
+        private
+
+        def load_file(path)
+          ensure_config_file!(path)
+
+          raw = YAML.load_file(path)
+          raise RSMP::ConfigurationError, "Config #{path} must be a hash" unless raw.is_a?(Hash) || raw.nil?
+
+          raw || {}
+        rescue Psych::SyntaxError => e
+          raise RSMP::ConfigurationError, "Cannot read config file #{path}: #{e}"
+        end
+
+        def ensure_config_file!(path)
+          raise RSMP::ConfigurationError, 'not found' unless File.exist?(path)
+          raise RSMP::ConfigurationError, 'is not a file' unless File.file?(path)
+          raise RSMP::ConfigurationError, 'must be a YAML file (.yml or .yaml)' unless yaml_file?(path)
+        end
+
+        def yaml_file?(path)
+          %w[.yml .yaml].include?(File.extname(path).downcase)
+        end
+
+        def config_settings(raw)
+          settings = raw.dup
+          settings.delete('log')
+          settings
+        end
+
+        def resolve_mode(mode, raw)
+          mode = mode.to_s
+          return mode if %w[site supervisor].include?(mode)
+          raise RSMP::ConfigurationError, "Unknown config mode #{mode.inspect}" unless mode == 'auto'
+
+          return 'site' if raw.key?('local_supervisor')
+          return 'supervisor' if raw.key?('local_site')
+
+          raise RSMP::ConfigurationError,
+                'Cannot infer validator config mode; use --mode site or --mode supervisor'
+        end
+
+        def options_class_for(mode)
+          case mode
+          when 'site'
+            RSMP::Validator::SiteTest::Options
+          when 'supervisor'
+            RSMP::Validator::SupervisorTest::Options
+          else
+            raise RSMP::ConfigurationError, "Unknown config mode #{mode.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/configuration/loader.rb

@@ -27,6 +27,12 @@ module RSMP
 
         def ensure_config_exists!(path, missing_message)
           abort_with_error missing_message unless File.exist?(path)
+          abort_with_error "Config #{path} is not a file" unless File.file?(path)
+          abort_with_error "Config #{path} must be a YAML file (.yml or .yaml)" unless yaml_file?(path)
+        end
+
+        def yaml_file?(path)
+          %w[.yml .yaml].include?(File.extname(path).downcase)
         end
 
         def validate_config_hash!(raw, path)

data/lib/rsmp/validator/configuration/sxls_override.rb

@@ -0,0 +1,33 @@
+module RSMP
+  module Validator
+    module Configuration
+      # Parses CLI SXL overrides.
+      module SxlsOverride
+        def apply_auto_node_overrides!(raw_config)
+          apply_auto_node_sxls_override!(raw_config) if sxls_override
+        end
+
+        def apply_auto_node_sxls_override!(raw_config)
+          sxls = parse_sxls(sxls_override)
+          if mode == :supervisor
+            raw_config['sites'] ||= {}
+            raw_config['sites']['default'] ||= {}
+            raw_config['sites']['default']['sxls'] = sxls
+          else
+            raw_config['sxls'] = sxls
+          end
+        end
+
+        def parse_sxls(value)
+          value.split(',').each_with_object({}) do |item, memo|
+            parts = item.split(':')
+            abort_with_error "Invalid --sxls item #{item.inspect}, expected name:version" unless parts.length == 2
+
+            name, version = parts
+            memo[name] = version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/configuration/validation.rb

@@ -1,7 +1,7 @@
 module RSMP
   module Validator
     module Configuration
-      # Private helpers for validating and normalizing configuration values.
+      # Private helpers for validating configuration values.
       module Validation
         private
 
@@ -75,40 +75,6 @@ module RSMP
           timeouts = config['timeouts']
           abort_with_error "Error: config 'timeouts' settings is missing or empty" if timeouts.nil? || timeouts == {}
         end
-
-        def normalize_core_version!
-          core_version = ENV['CORE_VERSION'] || config['core_version'] || RSMP::Schema.latest_core_version
-          core_version = RSMP::Schema.latest_core_version if core_version == 'latest'
-
-          known_versions = RSMP::Schema.core_versions
-          normalized = normalized_core_version(core_version, known_versions)
-          return config['core_version'] = normalized.to_s if normalized
-
-          abort_with_error "Unknown core version #{core_version}, must be one of [#{known_versions.join(', ')}]."
-        end
-
-        def normalized_core_version(core_version, known_versions)
-          known_versions.map { |v| Gem::Version.new(v) }.sort.reverse.detect do |v|
-            Gem::Requirement.new(core_version).satisfied_by?(v)
-          end
-        end
-
-        def normalize_sxls!
-          sxls = config['sxls']
-          if sxls.nil?
-            config['sxls'] = [{ 'name' => 'tlc', 'version' => RSMP::Schema.latest_version(:tlc) }]
-            return
-          end
-
-          sxls.each do |sxl|
-            name = sxl['name']
-            abort_with_error 'SXL name cannot be core.' if name.to_s == 'core'
-
-            RSMP::Schema.find_schema! name, sxl['version'], lenient: true
-          rescue RSMP::Schema::UnknownSchemaError => e
-            abort_with_error "Unknown SXL #{name} #{sxl['version']}: #{e}"
-          end
-        end
       end
     end
   end

data/lib/rsmp/validator/configuration/version_normalization.rb

@@ -0,0 +1,56 @@
+module RSMP
+  module Validator
+    module Configuration
+      # Canonicalizes the versions used by filters and compliance metadata.
+      # Embedded RSMP nodes retain configured legacy spellings for wire
+      # compatibility; the rsmp gem normalizes them only for schema lookup.
+      module VersionNormalization
+        private
+
+        def normalize_core_version!
+          core_version = config['core_version'] || RSMP::Schema.latest_core_version
+          config['core_version'] = canonical_core_version(core_version)
+        end
+
+        def canonical_core_version(core_version)
+          core_version = RSMP::Schema.latest_core_version if core_version == 'latest'
+
+          known_versions = RSMP::Schema.core_versions
+          normalized = normalized_core_version(core_version, known_versions)
+          return normalized.to_s if normalized
+
+          abort_with_error "Unknown core version #{core_version}, must be one of [#{known_versions.join(', ')}]."
+        end
+
+        def normalized_core_version(core_version, known_versions)
+          known_versions.map { |v| Gem::Version.new(v) }.sort.reverse.detect do |v|
+            Gem::Requirement.new(core_version).satisfied_by?(v)
+          end
+        end
+
+        def normalize_sxls!
+          sxls = config['sxls']
+          if sxls.nil?
+            config['sxls'] = [{ 'name' => 'tlc', 'version' => RSMP::Schema.latest_version(:tlc) }]
+            return
+          end
+
+          sxls.each do |sxl|
+            name = sxl['name']
+            abort_with_error 'SXL name cannot be core.' if name.to_s == 'core'
+
+            sxl['version'] = canonical_sxl_version(name, sxl['version'])
+          end
+        end
+
+        def canonical_sxl_version(name, version)
+          normalized = RSMP::Schema.sanitize_version(version.to_s)
+          RSMP::Schema.find_schema! name, normalized
+          normalized
+        rescue RSMP::Schema::UnknownSchemaError => e
+          abort_with_error "Unknown SXL #{name} #{version}: #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/configuration.rb

@@ -1,7 +1,9 @@
 require 'yaml'
 require_relative 'configuration/loader'
 require_relative 'configuration/validation'
+require_relative 'configuration/version_normalization'
 require_relative 'configuration/secrets'
+require_relative 'configuration/sxls_override'
 
 module RSMP
   module Validator
@@ -9,7 +11,9 @@ module RSMP
     module Configuration
       include Loader
       include Validation
+      include VersionNormalization
       include Secrets
+      include SxlsOverride
 
       def load_tester_config
         config_path = get_config_path
@@ -19,15 +23,15 @@ module RSMP
           missing_message: "#{mode.capitalize} config file #{config_path} is missing"
         )
 
-        apply_env_overrides!(raw_config)
+        apply_cli_overrides!(raw_config)
         options = build_tester_options(raw_config, config_path)
         apply_loaded_config(options)
         validate_and_finalize_config!(config_path)
       end
 
-      def apply_env_overrides!(raw_config)
-        raw_config['core_version'] = ENV['CORE_VERSION'] if ENV['CORE_VERSION']
-        raw_config['sxls'] = parse_sxls(ENV['SXLS']) if ENV['SXLS']
+      def apply_cli_overrides!(raw_config)
+        raw_config['core_version'] = core_version_override if core_version_override
+        raw_config['sxls'] = parse_sxls(sxls_override) if sxls_override
       end
 
       def validate_and_finalize_config!(config_path)
@@ -49,7 +53,7 @@ module RSMP
           using_message: '',
           missing_message: "Auto #{mode} config file #{path} is missing"
         )
-        raw_config['sxls'] = parse_sxls(ENV['SXLS']) if ENV['SXLS']
+        apply_auto_node_overrides!(raw_config)
         options_class = auto_node_options_class_for(raw_config)
         options = build_options_from_raw(raw_config, path, options_class)
         self.auto_node_config = options.to_h
@@ -58,17 +62,17 @@ module RSMP
 
       def get_config_path(local: false)
         mode_name = mode.to_s
-        config_path = get_config_path_from_env(mode_name) || get_config_path_from_validator_yaml(mode_name)
+        config_path = config_path_option(mode_name) || get_config_path_from_validator_yaml(mode_name)
         abort_with_error "#{mode_name.capitalize} config path not set" unless config_path && config_path != ''
 
         config_path = File.expand_path(config_path) if local
+        self.config_path = config_path
         config_path
       end
 
       def auto_node_config_path
-        env_key = mode == :site ? 'AUTO_SITE_CONFIG' : 'AUTO_SUPERVISOR_CONFIG'
-        env_path = ENV.fetch(env_key, nil)
-        return env_path if env_path && !env_path.empty?
+        option_path = auto_config_path_option(mode.to_s)
+        return option_path if option_path && !option_path.empty?
 
         ref_path = 'config/validator.yaml'
         return nil unless File.exist? ref_path
@@ -98,9 +102,18 @@ module RSMP
 
       private
 
-      def get_config_path_from_env(mode_name)
-        key = "#{mode_name.upcase}_CONFIG"
-        ENV.fetch(key, nil)
+      def config_path_option(mode_name)
+        case mode_name
+        when 'site' then site_config_path
+        when 'supervisor' then supervisor_config_path
+        end
+      end
+
+      def auto_config_path_option(mode_name)
+        case mode_name
+        when 'site' then auto_site_config_path
+        when 'supervisor' then auto_supervisor_config_path
+        end
       end
 
       def get_config_path_from_validator_yaml(mode_name)
@@ -114,16 +127,6 @@ module RSMP
       def warning(message)
         log "Warning: #{message}", level: :warning
       end
-
-      def parse_sxls(value)
-        value.split(',').each_with_object({}) do |item, memo|
-          parts = item.split(':')
-          abort_with_error "Invalid SXLS item #{item.inspect}, expected name:version" unless parts.length == 2
-
-          name, version = parts
-          memo[name] = version
-        end
-      end
     end
   end
 end

data/lib/rsmp/validator/helpers/alarms.rb

@@ -40,7 +40,7 @@ module RSMP
         end
 
         def build_alarm_matchers(site_proxy)
-          if RSMP::Proxy.version_meets_requirement? site_proxy.core_version, '>=3.2'
+          if RSMP::Proxy.version_meets_requirement? site_proxy.core_version, '>=3.2.0'
             [/Issue/, /Active/, /inActive/]
           else
             [/issue/i, /active/i, /inactive/i]

data/lib/rsmp/validator/helpers/clock.rb

@@ -4,11 +4,11 @@ module RSMP
       # Helper methods for testing RSMP clock functionality.
       module Clock
         def with_clock_set(site_proxy, clock, within:)
-          site_proxy.tlc.set_clock(clock, within:)
+          site_proxy.tlc.set_clock!(clock, within:)
           site_proxy.clear_alarm_timestamps
           yield
         ensure
-          site_proxy.tlc.set_clock(Time.now.utc, within:)
+          site_proxy.tlc.set_clock!(Time.now.utc, within:)
         end
       end
     end