rsmp-validator 0.1.0

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

@@ -0,0 +1,110 @@
+module RSMP
+  module Validator
+    module Helpers
+      # Helpers for validating the sequence of messages during RSMP connection establishment.
+      module Handshake
+        EXPECTED_VERSION_EXCHANGE_MESSAGES = [
+          'in:Version',
+          'out:MessageAck',
+          'out:Version',
+          'in:MessageAck'
+        ].freeze
+
+        EXPECTED_WATCHDOG_EXCHANGE_MESSAGES = [
+          'in:Watchdog',
+          'out:MessageAck',
+          'out:Watchdog',
+          'in:MessageAck'
+        ].freeze
+
+        EXPECTED_COMPONENT_LIST_MESSAGES = [
+          'in:ComponentList',
+          'out:MessageAck'
+        ].freeze
+
+        def get_connection_message(core_version, length)
+          timeout = RSMP::Validator.get_config('timeouts', 'ready')
+          got = nil
+
+          RSMP::Validator::SiteTester.isolated(
+            'collect' => { timeout: timeout, num: length, ingoing: true, outgoing: true },
+            'sites' => { 'default' => { 'rsmp_versions' => [core_version] } }
+          ) do |task, _supervisor, site|
+            assert(site.ready?, 'expected site to be ready')
+            collector = site.collector
+            collector.use_task task
+            collector.wait!
+            got = collector.messages.map { |message| "#{message.direction}:#{message.type}" }
+          end
+          got
+        rescue Async::TimeoutError
+          raise "Did not collect #{length} messages within #{timeout}s"
+        end
+
+        def check_sequence_v311_to_v313(core_version)
+          expected_version_messages = EXPECTED_VERSION_EXCHANGE_MESSAGES
+          expected_watchdog_messages = EXPECTED_WATCHDOG_EXCHANGE_MESSAGES
+
+          length = expected_version_messages.length + expected_watchdog_messages.length
+          got = get_connection_message core_version, length
+
+          expect_sequence_part!(
+            got[0..3],
+            expected: expected_version_messages,
+            forbidden: ['in:AggregatedStatus', 'in:Watchdog', 'in:Alarm'],
+            context: 'version exchange'
+          )
+
+          expect_sequence_part!(
+            got[4..7],
+            expected: expected_watchdog_messages,
+            forbidden: ['in:AggregatedStatus', 'in:Alarm'],
+            context: 'watchdog exchange'
+          )
+        end
+
+        def expect_sequence_part!(got_part, expected:, forbidden:, context:)
+          forbidden.each do |message|
+            type = message.split(':').last
+            assert(
+              !got_part.include?(message),
+              "#{type} not allowed during #{context}: #{got_part}"
+            )
+          end
+
+          assert(
+            got_part.tally == expected.tally,
+            "Wrong #{context} part, must contain #{expected}, got #{got_part}"
+          )
+        end
+
+        def check_sequence_v314_or_later(version)
+          expected = EXPECTED_VERSION_EXCHANGE_MESSAGES + EXPECTED_WATCHDOG_EXCHANGE_MESSAGES
+          got = get_connection_message version, expected.length
+          assert(got == expected, "Expected connection sequence #{expected.inspect}, got #{got.inspect}")
+        end
+
+        def check_sequence_v330(version)
+          expected = EXPECTED_VERSION_EXCHANGE_MESSAGES +
+                     EXPECTED_WATCHDOG_EXCHANGE_MESSAGES +
+                     EXPECTED_COMPONENT_LIST_MESSAGES
+          got = get_connection_message version, expected.length
+          assert(got == expected, "Expected connection sequence #{expected.inspect}, got #{got.inspect}")
+        end
+
+        def check_sequence(version)
+          case version
+          when '3.1.1', '3.1.2', '3.1.3'
+            check_sequence_v311_to_v313 version
+          when '3.1.4', '3.1.5', '3.2', '3.2.1', '3.2.2'
+            check_sequence_v314_or_later version
+          when '3.3.0'
+            check_sequence_v330 version
+          else
+            raise "Unknown rsmp version #{version}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module RSMP
+  module Validator
+    module Helpers
+      # Helper methods for testing RSMP input/output functionality.
+      module Input
+        include Status
+
+        def force_input_and_confirm(site_proxy, input:, value:, within:)
+          site_proxy.tlc.force_input(input:, status: 'True', value:, within:)
+          digit = (value == 'True' ? '1' : '0')
+
+          wait_for_status(
+            site_proxy,
+            "input #{input} to be #{value}",
+            [
+              { 'sCI' => 'S0003', 'n' => 'inputstatus', 's' => /^.{#{input - 1}}#{digit}/ }
+            ]
+          )
+        end
+
+        def switch_input(site_proxy, indx, within:)
+          site_proxy.tlc.set_input(input: indx.to_s, status: 'True', within:)
+
+          wait_for_status(
+            site_proxy,
+            "input #{indx} to be True",
+            [
+              { 'sCI' => 'S0003', 'n' => 'inputstatus', 's' => /^.{#{indx - 1}}1/ }
+            ]
+          )
+
+          site_proxy.tlc.set_input(input: indx.to_s, status: 'False', within:)
+          wait_for_status(
+            site_proxy,
+            "input #{indx} to be False",
+            [{ 'sCI' => 'S0003', 'n' => 'inputstatus', 's' => /^.{#{indx - 1}}0/ }]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RSMP
+  module Validator
+    module Helpers
+      # Helper methods for testing RSMP security code handling.
+      module Security
+        def wrong_security_code(site_proxy)
+          log 'Try to force detector logic with wrong security code'
+          command_list = RSMP::CommandList.new(:M0008, :setForceDetectorLogic,
+                                               securityCode: '1111',
+                                               status: 'True',
+                                               mode: 'True').to_a
+          component = RSMP::Validator.get_config('components', 'detector_logic').keys[0]
+          timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+          site_proxy.send_command_and_collect(command_list, component: component,
+                                                            within: timeout).ok!
+        end
+
+        def require_security_codes
+          return if RSMP::Validator.config.dig 'secrets', 'security_codes'
+
+          skip 'Security codes are not configured'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module RSMP
+  module Validator
+    module Helpers
+      # Helper methods for testing RSMP signal plan functionality.
+      module SignalPlans
+        def with_cycle_time_extended(site_proxy, extension = 5, &block)
+          timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+          plan = site_proxy.tlc.read_current_plan
+          time = read_plan_cycle_time(site_proxy, plan)
+          need_to_reset = true
+          time_extended = time + extension
+          site_proxy.tlc.set_cycle_time(plan: plan, cycle_time: time_extended, within: timeout)
+          verify_cycle_time(site_proxy, plan, time_extended)
+          block.yield
+        ensure
+          if need_to_reset
+            log 'Reset cycle time'
+            site_proxy.tlc.set_cycle_time(plan: plan, cycle_time: time, within: timeout)
+          end
+        end
+
+        private
+
+        def read_plan_cycle_time(site_proxy, plan)
+          time = site_proxy.tlc.read_cycle_times[plan]
+          assert(!time.nil?, 'Site returned empty cycle times list')
+          time
+        end
+
+        def verify_cycle_time(site_proxy, plan, expected)
+          actual = site_proxy.tlc.read_cycle_times[plan]
+          assert(actual == expected, "Expected cycle time #{expected}, got #{actual}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+require 'securerandom'
+
+module RSMP
+  module Validator
+    module Helpers
+      module SignalPriority
+        # Match a specific status response or update
+        class S0033Matcher < RSMP::StatusMatcher
+          attr_accessor :state
+
+          def initialize(want, request_id:, state: nil)
+            super(want)
+            @request_id = request_id
+            @state = state
+            @latest_state = nil
+          end
+
+          def match(item)
+            super_matched = super
+            if super_matched == true
+              state = find_request_state item['s']
+              if state == @state.to_s && state != @latest_state
+                @latest_state = state
+                true
+              else
+                false
+              end
+            else
+              super_matched
+            end
+          end
+
+          def find_request_state(list)
+            priority = list.find { |prio| prio['r'] == @request_id }
+            priority['s'] if priority
+          end
+        end
+
+        # Helper queue for managing signal priority requests during tests.
+        class RequestHelper < RSMP::Queue
+          include RSMP::Validator::Helpers::Status
+
+          def initialize(site_proxy, component:, signal_group_id:, timeout:, task:)
+            super(site_proxy,
+                  filter: RSMP::Filter.new(
+                    type: 'StatusUpdate',
+                    ingoing: true,
+                    outgoing: false,
+                    component: component
+                  ),
+                  task: task)
+            @site_proxy = site_proxy
+            @component = component
+            @signal_group_id = signal_group_id
+            @request_id = SecureRandom.uuid[0..3]
+            @matcher = S0033Matcher.new({ 'cCI' => 'S0033', 'q' => 'recent' }, request_id: @request_id)
+            @subscribe_list = [{ 'sCI' => 'S0033', 'n' => 'status', 'uRt' => '0' }]
+            @subscribe_list.map! { |item| item.merge!('sOc' => true) } if @site_proxy.tlc.use_soc?
+            @unsubscribe_list = [{ 'sCI' => 'S0033', 'n' => 'status' }]
+            @got = []
+            @timeout = timeout
+          end
+
+          def run
+            start
+            yield
+          ensure
+            stop
+          end
+
+          def request(level: 7, eta: 2, vehicle_type: 'car')
+            command_list = RSMP::CommandList.new(:M0022, :requestPriority,
+                                                 'requestId' => @request_id,
+                                                 'signalGroupId' => @signal_group_id,
+                                                 'type' => 'new',
+                                                 'level' => level,
+                                                 'eta' => eta,
+                                                 'vehicleType' => vehicle_type).to_a
+            @site_proxy.send_command(command_list, component: @component)
+          end
+
+          def request_unrelated(level: 7, eta: 2, vehicle_type: 'car')
+            command_list = RSMP::CommandList.new(:M0022, :requestPriority,
+                                                 'requestId' => SecureRandom.uuid[0..3],
+                                                 'signalGroupId' => @signal_group_id,
+                                                 'type' => 'new',
+                                                 'level' => level,
+                                                 'eta' => eta,
+                                                 'vehicleType' => vehicle_type).to_a
+            @site_proxy.send_command(command_list, component: @component)
+          end
+
+          def cancel
+            command_list = RSMP::CommandList.new(:M0022, :requestPriority,
+                                                 requestId: @request_id,
+                                                 type: 'cancel').to_a
+            @site_proxy.send_command(command_list, component: @component)
+          end
+
+          def expect(state)
+            @matcher.state = state
+            wait_for_message timeout: @timeout
+          rescue RSMP::TimeoutError
+            raise RSMP::TimeoutError, "Priority request did not reach state #{state} within #{@timeout}s"
+          end
+
+          private
+
+          def accept_message?(message)
+            super && get_items(message).any? { |item| @matcher.match(item) }
+          end
+
+          def start
+            start_receiving
+            @site_proxy.subscribe_to_status @subscribe_list, component: @component
+          end
+
+          def stop
+            @site_proxy.unsubscribe_to_status @unsubscribe_list, component: @component
+            stop_receiving
+          end
+
+          def get_items(message)
+            message.attributes['sS'] || []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+module RSMP
+  module Validator
+    module Helpers
+      # Helper methods for testing RSMP site startup sequences.
+      module Startup
+        include Status
+
+        # Tracks the startup signal group sequence for validation.
+        class SignalGroupSequence
+          attr_reader :sequence, :latest
+
+          def initialize(sequence)
+            @pos = []
+            @prev = []
+            @sequence = sequence
+            @num_groups = 0
+            @latest = nil
+          end
+
+          def num_started
+            @pos.count { |v| !v.nil? }
+          end
+
+          def num_done
+            @pos.count { |pos| pos == @sequence.length - 1 }
+          end
+
+          def done?
+            num_done == @num_groups
+          end
+
+          def check(states)
+            initialize_check(states)
+
+            states.each_char.with_index do |state, group_index|
+              position = @pos[group_index]
+              error = if position
+                        check_started_group(group_index, state, position)
+                      else
+                        check_not_started_group(group_index, state)
+                      end
+              return error if error
+            end
+
+            :ok
+          end
+
+          private
+
+          def initialize_check(states)
+            @latest = states
+            @num_groups = states.size
+          end
+
+          def check_not_started_group(group_index, state)
+            prev = @prev[group_index]
+            start = @sequence[0]
+            @pos[group_index] = 0 if state == start && !prev.nil? && prev != start
+            @prev[group_index] = state
+            nil
+          end
+
+          def check_started_group(group_index, state, position)
+            current = @sequence[position]
+            return nil if state == current
+
+            expected, next_position = expected_transition(position)
+            if state != expected
+              return "Group #{group_index} changed from #{current} to #{state}, must go to #{expected}"
+            end
+
+            @pos[group_index] = next_position
+            nil
+          end
+
+          def expected_transition(pos)
+            last = @sequence.length - 1
+            return [@sequence[last], last] if pos == last
+
+            next_pos = pos + 1
+            [@sequence[next_pos], next_pos]
+          end
+        end
+
+        def wait_normal_control(site_proxy, timeout: RSMP::Validator.get_config('timeouts', 'startup_sequence'))
+          site_proxy.tlc.wait_for_normal_control(timeout: timeout)
+        end
+
+        def verify_startup_sequence(site_proxy)
+          status_list = [{ 'sCI' => 'S0001', 'n' => 'signalgroupstatus' }]
+          subscribe_list, unsubscribe_list = build_subscribe_lists(site_proxy, status_list)
+          component = RSMP::Validator.get_config('main_component')
+          timeout = RSMP::Validator.get_config('timeouts', 'startup_sequence')
+          collector = RSMP::StatusCollector.new site_proxy, status_list, timeout: timeout
+          sequencer = SignalGroupSequence.new RSMP::Validator.get_config('startup_sequence')
+          collector_task = start_sequence_collector(collector, sequencer)
+          site_proxy.subscribe_to_status subscribe_list, component: component
+          yield
+          handle_startup_sequence_result(collector_task.wait, sequencer, collector, timeout)
+          wait_for_status(site_proxy, 'control mode to be startup',
+                          [{ 'sCI' => 'S0020', 'n' => 'controlmode', 's' => 'control' }])
+        ensure
+          site_proxy.unsubscribe_to_status unsubscribe_list, component: component
+        end
+
+        private
+
+        def build_subscribe_lists(site_proxy, status_list)
+          raw_list = RSMP::StatusList.new(status_list).to_a
+          subscribe_list = raw_list.map { |item| item.merge('uRt' => 0.to_s) }
+          subscribe_list.map! { |item| item.merge!('sOc' => true) } if site_proxy.tlc.use_soc?
+          [subscribe_list, raw_list]
+        end
+
+        def start_sequence_collector(collector, sequencer)
+          Async::Task.current.async do
+            log 'Verifying startup sequence'
+            collector.collect do |_message, item|
+              next unless item
+
+              handle_startup_sequence_item(item['s'], sequencer, collector)
+            end
+          end
+        end
+
+        def handle_startup_sequence_item(states, sequencer, collector)
+          status = sequencer.check(states)
+
+          if status == :ok
+            log "Startup sequence #{states}: OK"
+            return collector.complete if sequencer.done?
+
+            return false
+          end
+
+          log "Startup sequence #{states}: Fail"
+          collector.cancel status
+        end
+
+        def handle_startup_sequence_result(result, sequencer, collector, timeout)
+          case result
+          when :ok
+            log 'Startup sequence verified'
+          when :timeout
+            raise(
+              "Startup sequence '#{sequencer.sequence}' didn't complete in #{timeout}s, " \
+              "reached #{sequencer.latest}, #{sequencer.num_started} started, " \
+              "#{sequencer.num_done} done"
+            )
+          when :cancelled
+            raise "Startup sequence '#{sequencer.sequence}' not followed: #{collector.error}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module RSMP
+  module Validator
+    module Helpers
+      # Helper methods for requesting and subscribing to RSMP status values.
+      module Status
+        def wait_for_status(site_proxy, description, status_list, **options)
+          update_rate = options.fetch(:update_rate, 0)
+          timeout = options.fetch(:timeout, RSMP::Validator.get_config('timeouts', 'command'))
+          component_id = options.fetch(:component_id, RSMP::Validator.get_config('main_component'))
+          log "Wait for #{description}"
+          site_proxy.tlc.wait_for_status(
+            description,
+            RSMP::StatusList.new(status_list).to_a,
+            update_rate: update_rate,
+            timeout: timeout,
+            component_id: component_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/validator/lifecycle.rb

@@ -0,0 +1,99 @@
+module RSMP
+  module Validator
+    # Suite lifecycle: startup and shutdown of the Async reactor and auto nodes.
+    module Lifecycle
+      # Initialize the validator system at sus startup.
+      def setup(sus_config)
+        @verbose = sus_config.verbose?
+        @log_stream = determine_log_stream(sus_config)
+        determine_mode sus_config
+        initialize_logging log_settings: {} # minimal init so log() works during config loading
+        load_tester_config
+        load_auto_node_config
+        setup_logging # reinitialize with config-specific settings
+        build_auto_node
+        build_tester
+      end
+
+      # Determine the log stream based on sus config.
+      def determine_log_stream(sus_config)
+        if sus_config.respond_to?(:log_file_io) && sus_config.log_file_io
+          sus_config.log_file_io
+        elsif sus_config.respond_to?(:log_path) && sus_config.log_path
+          File.open(sus_config.log_path, 'w')
+        elsif sus_config.respond_to?(:log_to_stdout) && sus_config.log_to_stdout
+          $stdout
+        else
+          File.open(File::NULL, 'w')
+        end
+      end
+
+      # Set up logging with configuration-specific settings.
+      def setup_logging
+        settings = load_log_defaults('validator_log').merge('stream' => @log_stream)
+        settings = settings.deep_merge(config_log_settings) if config_log_settings
+        settings = settings.deep_merge(config['log']) if config.is_a?(Hash) && config['log']
+        initialize_logging log_settings: settings
+
+        self.node_log_settings = load_log_defaults('simulator/node_log').merge('stream' => @log_stream)
+      end
+
+      # Called at sus startup: initializes the Async reactor and checks connectivity.
+      def before_suite
+        setup_reactor
+        error = run_startup_checks
+        raise error if error
+      rescue RSMP::ConnectionError => e
+        abort_startup(e, e.message)
+      rescue StandardError => e
+        abort_startup(e, e.inspect)
+      end
+
+      # Called at sus shutdown: stops the auto node and reactor.
+      def after_suite
+        reactor.run do |_task|
+          auto_node&.stop
+        ensure
+          reactor.interrupt
+        end
+        # Explicitly close the reactor now, while the log stream is still open.
+        # Without this, Ruby's fiber scheduler hook fires after the File.open block
+        # has closed the log file, causing IOError when cancelled tasks try to log.
+        reactor.close
+      rescue StandardError
+        nil
+      end
+
+      # Initialize the Async reactor.
+      def setup_reactor
+        @reactor = Async::Reactor.new
+        reactor.annotate 'reactor'
+      end
+
+      private
+
+      def load_log_defaults(name)
+        path = File.expand_path("../../../config/#{name}.yaml", __dir__)
+        YAML.load_file(path)
+      end
+
+      def run_startup_checks
+        error = nil
+        reactor.run do |_task|
+          auto_node&.start
+          check_connection
+        rescue StandardError => e
+          error = e
+        ensure
+          reactor.interrupt
+        end
+        error
+      end
+
+      def abort_startup(exception, message)
+        warn "Aborting: #{message}".colorize(:red)
+        raise exception
+      end
+    end
+  end
+end

data/lib/rsmp/validator/log.rb

@@ -0,0 +1,11 @@
+module RSMP
+  module Validator
+    # Logging helpers for use in tests and validator infrastructure.
+    module Log
+      # Log the start of an action
+      def log(action, **options)
+        RSMP::Validator.log(action, **options)
+      end
+    end
+  end
+end