rsmp-validator 0.1.0

data/lib/rsmp/validator/mode_detection.rb

@@ -0,0 +1,84 @@
+module RSMP
+  module Validator
+    # Methods for detecting test mode and building the appropriate tester and auto node.
+    module ModeDetection
+      # Print an error message and exit.
+      def abort_with_error(error)
+        warn "Error: #{error}".colorize(:red)
+        exit 1
+      end
+
+      # Initial connectivity check to verify we can connect to the site/supervisor being tested.
+      def check_connection
+        log "Initial #{mode} connection check"
+        if mode == :site
+          SiteTester.instance.connected { nil }
+        elsif mode == :supervisor
+          SupervisorTester.instance.connected { nil }
+        end
+      end
+
+      # Set whether we are testing a site or a supervisor.
+      def select_mode(mode)
+        if self.mode
+          abort_with_error 'Cannot run tests in both test/site/ and test/supervisor/' if self.mode != mode
+          return
+        end
+
+        case mode
+        when :site, :supervisor
+          self.mode = mode
+        else
+          abort_with_error "Unknown test mode: #{mode}"
+        end
+      end
+
+      # Determine mode from test file paths.
+      def determine_mode(sus_config)
+        paths = sus_config.paths.any? ? sus_config.paths : sus_config.test_paths
+        site_dir = File.expand_path('test/site', sus_config.root)
+        supervisor_dir = File.expand_path('test/supervisor', sus_config.root)
+
+        paths.each do |path_str|
+          expanded = File.expand_path(path_str, sus_config.root)
+          inferred = infer_mode_from_path(expanded, site_dir, supervisor_dir)
+          select_mode inferred if inferred
+        end
+
+        abort_with_error 'Could not determine test mode (site or supervisor) from test paths' unless mode
+      end
+
+      # Determine the test mode from a single expanded path.
+      def infer_mode_from_path(path, site_dir, supervisor_dir)
+        return :site if path == site_dir || path.start_with?("#{site_dir}/")
+        return :supervisor if path == supervisor_dir || path.start_with?("#{supervisor_dir}/")
+
+        nil
+      end
+
+      # Build the tester instance.
+      def build_tester
+        if mode == :site
+          SiteTester.instance = SiteTester.new
+        elsif mode == :supervisor
+          SupervisorTester.instance = SupervisorTester.new
+        else
+          abort_with_error "Unknown test mode: #{mode}"
+        end
+      end
+
+      # Build the auto node (local site or supervisor to be tested).
+      def build_auto_node
+        return unless auto_node_config
+
+        if mode == :site
+          self.auto_node = AutoSite.new
+        elsif mode == :supervisor
+          self.auto_node = AutoSupervisor.new
+        else
+          abort_with_error "Unknown test mode: #{mode}"
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/options/site_test_options.rb

@@ -0,0 +1,58 @@
+require 'rsmp'
+
+module RSMP
+  module Validator
+    module SiteTest
+      # Configuration options for site testing.
+      class Options < RSMP::Options
+        def schema_file
+          'site_test.json'
+        end
+
+        def schema_path
+          File.expand_path("../../../schemas/#{schema_file}", __dir__)
+        end
+
+        private
+
+        def apply_defaults(options)
+          return options unless options.is_a?(Hash)
+
+          local_supervisor = options['local_supervisor']
+          return options unless local_supervisor.is_a?(Hash)
+
+          local_supervisor['sites'] ||= {}
+          local_supervisor['sites']['default'] =
+            merge_default_defaults(options, local_supervisor.dig('sites', 'default'))
+          local_supervisor = RSMP::Supervisor::Options.new(local_supervisor).to_h
+          options.merge('local_supervisor' => local_supervisor)
+        end
+
+        def merge_default_defaults(options, default)
+          merged_default = default.is_a?(Hash) ? default.dup : {}
+
+          site_defaults.each do |key|
+            value = options[key]
+            next if value.nil? || merged_default.key?(key)
+
+            merged_default[key] = value
+          end
+
+          merged_default
+        end
+
+        def site_defaults
+          %w[
+            sxls
+            core_version
+            rsmp_versions
+            intervals
+            timeouts
+            components
+            skip_validation
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/options/supervisor_test_options.rb

@@ -0,0 +1,51 @@
+require 'rsmp'
+
+module RSMP
+  module Validator
+    module SupervisorTest
+      # Configuration options for supervisor testing.
+      class Options < RSMP::Options
+        def schema_file
+          'supervisor_test.json'
+        end
+
+        def schema_path
+          File.expand_path("../../../schemas/#{schema_file}", __dir__)
+        end
+
+        private
+
+        def apply_defaults(options)
+          return options unless options.is_a?(Hash)
+
+          local_site = options['local_site']
+          return options unless local_site.is_a?(Hash)
+
+          %w[
+            sxls
+            core_version
+            rsmp_versions
+            intervals
+            timeouts
+            components
+            skip_validation
+          ].each do |key|
+            value = options[key]
+            next if value.nil? || local_site.key?(key)
+
+            local_site[key] = value
+          end
+
+          site_options_class = if local_site['type'] == 'tlc'
+                                 RSMP::TLC::TrafficControllerSite::Options
+                               else
+                                 RSMP::Site::Options
+                               end
+          local_site = site_options_class.new(local_site).to_h
+
+          options.merge('local_site' => local_site)
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/site_tester.rb

@@ -0,0 +1,113 @@
+module RSMP
+  module Validator
+    # Helper class for testing RSMP sites.
+    # Runs a local RSMP supervisor inside an Async reactor.
+    # Only one site is expected to connect to the supervisor.
+    class SiteTester < RSMP::Validator::Tester
+      class << self
+        attr_accessor :instance
+
+        def connected(options = {}, &)
+          instance.connected(options, &)
+        end
+
+        def reconnected(options = {}, &)
+          instance.reconnected(options, &)
+        end
+
+        def disconnected(&)
+          instance.disconnected(&)
+        end
+
+        def isolated(options = {}, &)
+          instance.isolated(options, &)
+        end
+
+        def stop
+          instance.stop
+        end
+      end
+
+      def parse_config
+        setup_supervisor_config
+        validate_timeouts
+      end
+
+      def setup_supervisor_config
+        @supervisor_config = config['local_supervisor']
+        raise "config 'local_supervisor' is missing" unless @supervisor_config
+
+        @supervisor_config['max_sites'] ||= 1
+        @supervisor_config['sites'] ||= {}
+        @supervisor_config['sites']['default'] ||= {}
+        apply_security_codes
+      end
+
+      def apply_security_codes
+        security_codes = config.dig('secrets', 'security_codes')
+        return unless security_codes && !@supervisor_config['sites']['default']['security_codes']
+
+        @supervisor_config['sites']['default']['security_codes'] = security_codes
+      end
+
+      def validate_timeouts
+        %w[
+          connect
+          ready
+          status_response
+          status_update
+          subscribe
+          command
+          command_response
+          alarm
+          disconnect
+        ].each do |key|
+          raise "config 'timeouts/#{key}' is missing" unless config['timeouts'][key]
+        end
+      end
+
+      def build_node(options)
+        logger = create_supervisor_logger(@supervisor_config)
+        supervisor_settings = ConfigNormalizer.normalize_supervisor_settings(@supervisor_config.deep_merge(options))
+
+        RSMP::Supervisor.new(
+          supervisor_settings: supervisor_settings,
+          logger: logger,
+          collect: options['collect']
+        )
+      end
+
+      def wait_for_connection
+        @proxy = @node.proxies.first
+        return if @proxy
+
+        log 'Waiting for site to connect'
+        @proxy = @node.wait_for_site(:any, timeout: config['timeouts']['connect'])
+      rescue RSMP::TimeoutError
+        raise RSMP::ConnectionError, "Site did not connect within #{config['timeouts']['connect']}s"
+      end
+
+      def wait_for_handshake
+        return if @proxy.ready?
+
+        log 'Waiting for handshake to complete'
+        @proxy.wait_for_state :ready, timeout: config['timeouts']['ready']
+        log 'Ready'
+        return if @initial_unsubscribe_done
+
+        @proxy.unsubscribe_from_all component: RSMP::Validator.get_config('main_component')
+        @initial_unsubscribe_done = true
+      end
+
+      def create_supervisor_logger(supervisor_config)
+        log_settings = supervisor_config.is_a?(Hash) ? supervisor_config['log'] : nil
+        logger_settings = RSMP::Validator.node_log_settings.merge('prefix' => '[SUPERVISOR]')
+        return RSMP::Logger.new(logger_settings) unless log_settings && !log_settings.empty?
+
+        logger_settings.merge!(log_settings)
+        logger_settings.delete('stream') if log_settings['path']
+        RSMP::Logger.new(logger_settings)
+      end
+    end
+  end
+end

data/lib/rsmp/validator/supervisor_tester.rb

@@ -0,0 +1,76 @@
+require 'rsmp'
+require 'singleton'
+require 'colorize'
+
+module RSMP
+  module Validator
+    # Helper class for testing RSMP supervisors.
+    # Runs a local RSMP site inside an Async reactor.
+    class SupervisorTester < RSMP::Validator::Tester
+      class << self
+        attr_accessor :instance
+
+        def connected(options = {}, &)
+          instance.connected(options, &)
+        end
+
+        def reconnected(options = {}, &)
+          instance.reconnected(options, &)
+        end
+
+        def disconnected(&)
+          instance.disconnected(&)
+        end
+
+        def isolated(options = {}, &)
+          instance.isolated(options, &)
+        end
+      end
+
+      def parse_config
+        @site_config = config['local_site']
+        raise "config 'local_site' is missing" unless @site_config
+      end
+
+      def build_node(options)
+        klass = case @site_config['type']
+                when 'tlc'
+                  RSMP::TLC::TrafficControllerSite
+                else
+                  RSMP::Site
+                end
+        site_settings = ConfigNormalizer.normalize_site_settings(@site_config.deep_merge(options))
+        logger = create_site_logger(@site_config)
+        @site = klass.new(
+          site_settings: site_settings,
+          logger: logger,
+          collect: options['collect']
+        )
+      end
+
+      def wait_for_connection
+        log 'Waiting for connection to supervisor'
+        @proxy = @node.find_supervisor :any
+        @proxy.wait_for_state %i[connected ready], timeout: config['timeouts']['connect']
+      rescue RSMP::TimeoutError
+        raise RSMP::ConnectionError, "Could not connect to supervisor within #{config['timeouts']['connect']}s"
+      end
+
+      def wait_for_handshake
+        @proxy.wait_for_state :ready, timeout: config['timeouts']['ready']
+      rescue RSMP::TimeoutError
+        raise RSMP::ConnectionError, "Handshake didn't complete within #{config['timeouts']['ready']}s"
+      end
+
+      def create_site_logger(site_config)
+        log_settings = site_config.is_a?(Hash) ? site_config['log'] : nil
+        logger_settings = RSMP::Validator.node_log_settings.merge('prefix' => '[TLC]       ')
+        return RSMP::Logger.new(logger_settings) unless log_settings && !log_settings.empty?
+
+        logger_settings.merge!(log_settings)
+        logger_settings.delete('stream') if log_settings['path']
+        RSMP::Logger.new(logger_settings)
+      end
+    end
+  end
+end

data/lib/rsmp/validator/tester.rb

@@ -0,0 +1,101 @@
+require 'rsmp'
+require 'colorize'
+
+module RSMP
+  module Validator
+    # Base class for testing either a site or a supervisor.
+    # Handles running the corresponding local site/supervisor inside an Async reactor.
+    class Tester
+      include RSMP::Validator::Log
+
+      def self.sentinel_errors
+        @sentinel_errors ||= []
+      end
+
+      def config
+        RSMP::Validator.config
+      end
+
+      # Ensures that the site is connected.
+      # If the site is already connected, the block will be called immediately.
+      # Otherwise waits until the site is connected before calling the block.
+      def connected(options = {})
+        start options, 'Connecting'
+        wait_for_proxy
+        yield Async::Task.current, @node, @proxy
+      end
+
+      # Disconnects the site if connected, then waits until the site is connected
+      # before calling the block.
+      def reconnected(options = {})
+        stop 'Reconnecting'
+        start options
+        wait_for_proxy
+        yield Async::Task.current, @node, @proxy
+      end
+
+      # Like connected, except that the connection is closed after the test.
+      def isolated(options = {})
+        stop 'Isolating'
+        start options, 'Connecting'
+        wait_for_proxy
+        yield Async::Task.current, @node, @proxy
+        stop 'Isolating'
+      end
+
+      # Disconnects the site if connected before calling the block.
+      def disconnected
+        stop 'Disconnecting'
+        yield Async::Task.current
+      end
+
+      # Stop the rsmp supervisor
+      def stop(why = nil)
+        if @node
+          log why if why
+          @node.ignore_errors RSMP::DisconnectError do
+            @node.stop
+          end
+        end
+        @node = nil
+        @proxy = nil
+      end
+
+      private
+
+      def initialize
+        parse_config
+      end
+
+      # Start the tester node inside an async task that will persist between tests.
+      def start(options = {}, _why = nil)
+        return if @node
+
+        RSMP::Validator.reactor.async do |task|
+          task.annotate 'node runner'
+
+          @node = build_node options
+
+          RSMP::Validator.reactor.async do |sentinel|
+            sentinel.annotate 'sentinel'
+            while @node
+              e = @node.error_queue.dequeue
+              log "Sentinel warning: #{e.class}: #{e}"
+              self.class.sentinel_errors << e
+            end
+          end
+
+          @node.start
+        end
+      end
+
+      # Wait until communication has been established, and handshake completed.
+      def wait_for_proxy
+        wait_for_connection
+        wait_for_handshake
+      end
+
+      def parse_config; end
+    end
+  end
+end

data/lib/rsmp/validator/version.rb

@@ -0,0 +1,5 @@
+module RSMP
+  module Validator
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/rsmp/validator/version_filter.rb

@@ -0,0 +1,44 @@
+module RSMP
+  # Main module for RSMP Validator functionality.
+  module Validator
+    # Helpers for filtering tests by RSMP core and SXL version.
+    module VersionFilter
+      # Check if the configured SXL version satisfies the given requirement.
+      # @param requirement [String] Gem::Requirement-compatible string, e.g. ">= 1.0.7"
+      def self.sxl_matches?(requirement, name: nil)
+        sxl = configured_sxl(name)
+        version_satisfies?(requirement, sxl && sxl['version'])
+      end
+
+      # Check if the configured core version satisfies the given requirement.
+      # @param requirement [String] Gem::Requirement-compatible string, e.g. ">= 3.2"
+      def self.core_matches?(requirement)
+        version_satisfies?(requirement, RSMP::Validator.config['core_version'])
+      end
+
+      # Helper that does the version comparison.
+      def self.version_satisfies?(requirement, version_str)
+        return false unless version_str
+
+        version = Gem::Version.new(version_str)
+        Gem::Requirement.new(requirement).satisfied_by?(version)
+      end
+
+      def self.configured_sxl(name = nil)
+        sxls = RSMP::Validator.config['sxls'] || []
+        return sxls.first unless name
+
+        sxls.find { |sxl| sxl['name'] == name.to_s }
+      end
+    end
+
+    # Convenience module methods delegating to VersionFilter
+    def self.sxl_matches?(requirement, name: nil)
+      VersionFilter.sxl_matches?(requirement, name: name)
+    end
+
+    def self.core_matches?(requirement)
+      VersionFilter.core_matches?(requirement)
+    end
+  end
+end

data/lib/rsmp/validator.rb

@@ -0,0 +1,50 @@
+require 'rsmp'
+require 'colorize'
+require_relative 'validator/version'
+require_relative 'validator/log'
+require_relative 'validator/options/site_test_options'
+require_relative 'validator/options/supervisor_test_options'
+require_relative 'validator/config_normalizer'
+require_relative 'validator/configuration'
+require_relative 'validator/version_filter'
+require_relative 'validator/lifecycle'
+require_relative 'validator/mode_detection'
+require_relative 'validator/tester'
+require_relative 'validator/site_tester'
+require_relative 'validator/supervisor_tester'
+require_relative 'validator/auto_node'
+require_relative 'validator/auto_site'
+require_relative 'validator/auto_supervisor'
+require_relative 'validator/async_context'
+require_relative 'validator/helpers/connection'
+require_relative 'validator/helpers/status'
+require_relative 'validator/helpers/input'
+require_relative 'validator/helpers/clock'
+require_relative 'validator/helpers/security'
+require_relative 'validator/helpers/signal_plans'
+require_relative 'validator/helpers/alarms'
+require_relative 'validator/helpers/startup'
+require_relative 'validator/helpers/handshake'
+require_relative 'validator/helpers/signal_priority'
+
+module RSMP
+  # Main module for RSMP Validator functionality.
+  # Handles configuration, logging, and coordination between sus and the RSMP gem.
+  module Validator
+    extend Configuration
+    extend Lifecycle
+    extend ModeDetection
+
+    class << self
+      include RSMP::Logging
+
+      attr_accessor :config, :config_log_settings, :mode, :logger, :auto_node_config,
+                    :auto_node_log_settings, :auto_node, :node_log_settings
+    end
+
+    # Get the global Async reactor used for RSMP communication
+    def self.reactor
+      @reactor
+    end
+  end
+end

data/schemas/site_test.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "site_test.json",
+  "type": "object",
+  "properties": {
+    "local_supervisor": {
+      "type": "object",
+      "properties": {
+        "log": { "type": "object" }
+      },
+      "additionalProperties": true
+    },
+    "core_version": { "type": "string" },
+    "sxls": {
+      "type": "object",
+      "propertyNames": { "not": { "const": "core" } },
+      "additionalProperties": { "type": "string" }
+    },
+    "rsmp_versions": {
+      "oneOf": [
+        { "type": "string" },
+        { "type": "array", "items": { "type": "string" } }
+      ]
+    },
+    "timeouts": { "type": "object" },
+    "components": { "type": "object" },
+    "items": { "type": "object" },
+    "startup_sequence": { "type": ["string", "null"] },
+    "skip_validation": { "type": "array", "items": { "type": "string" } },
+    "secrets": { "type": "object" },
+    "alarm_triggers": { "type": "object" },
+    "log": { "type": "object" }
+  },
+  "required": ["local_supervisor"],
+  "additionalProperties": true
+}

data/schemas/supervisor_test.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "supervisor_test.json",
+  "type": "object",
+  "properties": {
+    "local_site": {
+      "type": "object",
+      "properties": {
+        "log": { "type": "object" }
+      },
+      "additionalProperties": true
+    },
+    "core_version": { "type": "string" },
+    "sxls": {
+      "type": "object",
+      "propertyNames": { "not": { "const": "core" } },
+      "additionalProperties": { "type": "string" }
+    },
+    "timeouts": { "type": "object" },
+    "components": { "type": "object" },
+    "items": { "type": "object" },
+    "skip_validation": { "type": "array", "items": { "type": "string" } },
+    "secrets": { "type": "object" },
+    "log": { "type": "object" }
+  },
+  "required": ["local_site"],
+  "additionalProperties": true
+}