rsmp-validator 0.1.1 → 0.3.2

data/lib/rsmp/validator.rb

@@ -4,6 +4,7 @@ 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_check'
 require_relative 'validator/config_normalizer'
 require_relative 'validator/configuration'
 require_relative 'validator/version_filter'
@@ -39,7 +40,10 @@ module RSMP
       include RSMP::Logging
 
       attr_accessor :config, :config_log_settings, :mode, :logger, :auto_node_config,
-                    :auto_node_log_settings, :auto_node, :node_log_settings
+                    :auto_node_log_settings, :auto_node, :node_log_settings,
+                    :core_version_override, :sxls_override, :site_config_path,
+                    :supervisor_config_path, :auto_site_config_path,
+                    :auto_supervisor_config_path, :config_path
     end
 
     # Get the global Async reactor used for RSMP communication

data/schemas/site_test.json

@@ -16,12 +16,6 @@
       "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" },

data/test/site/core/aggregated_status_spec.rb

@@ -11,18 +11,18 @@ describe 'Site::Core' do
         site_proxy.request_aggregated_status_and_collect(
           RSMP::Validator.get_config('main_component'),
           within: RSMP::Validator.get_config('timeouts', 'status_response')
-        ).ok!
+        ).value!
       end
     end
 
-    # Verify that aggregated status uses null for unused attributes, from SXL 1.1
-    # For SXL versions before 1.1 empty strings "" is also allowed.
+    # Verify that aggregated status uses null for unused attributes, from SXL 1.1.0
+    # For SXL versions before 1.1.0 empty strings "" is also allowed.
     #
     # 1. Given the is reconnected
     # 2. When we receive an aggregated status
     # 3. Then fP and fS should be null
     it 'uses null for functional position/state' do
-      with_site(:isolated, sxl: '>=1.1',
+      with_site(:isolated, sxl: '>=1.1.0',
                            'collect' => {
                              filter: RSMP::Filter.new(type: 'AggregatedStatus'),
                              timeout: RSMP::Validator.get_config('timeouts', 'ready'),
@@ -30,9 +30,7 @@ describe 'Site::Core' do
                              ingoing: true
                            }) do |site_proxy|
         collector = site_proxy.collector
-        collector.use_task Async::Task.current
-        collector.wait!
-        aggregated_status = site_proxy.collector.messages.first
+        aggregated_status = collector.wait!.first
 
         expect(aggregated_status).to be_a(RSMP::AggregatedStatus)
         expect(aggregated_status.attribute('fP')).to be_nil

data/test/site/core/connect_spec.rb

@@ -57,15 +57,15 @@ describe 'Site::Core' do
       check_sequence '3.1.5'
     end
 
-    # Verify the connection sequence when using rsmp core 3.2
+    # Verify the connection sequence when using rsmp core 3.2.0
     #
-    # 1. Given the site is connected and using core 3.2
+    # 1. Given the site is connected and using core 3.2.0
     # 2. When handshake messages are sent and received
     # 3. Then the handshake messages should be in the specified sequence corresponding to version 3.1.5
     # 4. And the connection sequence should be complete
-    it 'is correct for rsmp version 3.2' do
-      skip 'requires core == 3.2' unless RSMP::Validator.core_matches?('3.2')
-      check_sequence '3.2'
+    it 'is correct for rsmp version 3.2.0' do
+      skip 'requires core == 3.2.0' unless RSMP::Validator.core_matches?('3.2.0')
+      check_sequence '3.2.0'
     end
 
     # Verify the connection sequence when using rsmp core 3.2.1

data/test/site/core/disconnect_spec.rb

@@ -14,19 +14,15 @@ describe 'Site::Core' do
     it 'is closed if watchdogs are not acknowledged' do
       with_site(:isolated, sxl: '>=1.0.7') do |site_proxy|
         timeout = RSMP::Validator.get_config('timeouts', 'disconnect')
-        site_proxy.node.ignore_errors RSMP::DisconnectError do
-          log 'Disabling watchdog acknowledgements, site should disconnect'
-          def site_proxy.acknowledge(original)
-            if original.is_a? RSMP::Watchdog
-              log 'Not acknowledgning watchdog', message: original
-            else
-              super
-            end
+        log 'Disabling watchdog acknowledgements, site should disconnect'
+        def site_proxy.acknowledge(original)
+          if original.is_a? RSMP::Watchdog
+            log 'Not acknowledgning watchdog', message: original
+          else
+            super
           end
-          site_proxy.wait_for_state :disconnected, timeout: timeout
         end
-      rescue RSMP::TimeoutError
-        raise "Site did not disconnect within #{timeout}s"
+        site_proxy.wait_for_state!(:disconnected, timeout: timeout)
       end
     end
 
@@ -37,16 +33,11 @@ describe 'Site::Core' do
       with_site(:isolated, sxl: '>=1.0.7') do |site_proxy|
         timeout = RSMP::Validator.get_config('timeouts', 'disconnect')
 
-        wait_task = Async::Task.current.async do
-          site_proxy.wait_for_state :disconnected, timeout: timeout
-          raise RSMP::DisconnectError
-        rescue RSMP::TimeoutError
-          # ok, no disconnect happened
-        end
-
         log 'Stop sending watchdogs, site should not disconnect'
         site_proxy.with_watchdog_disabled do
-          wait_task.wait
+          result = site_proxy.wait_for_state :disconnected, timeout: timeout
+          assert(result.failure? && result.failure.code == :timeout,
+                 "Site disconnected unexpectedly: #{result.inspect}")
         end
       end
     end

data/test/site/core/message_buffer_spec.rb

@@ -0,0 +1,114 @@
+describe 'Site::Core' do
+  describe 'Message Buffer' do
+    def buffered_status_list(site_proxy)
+      status_list = [{ 'sCI' => 'S0001', 'n' => 'signalgroupstatus', 'uRt' => '1' }]
+      status_list.map! { |item| item.merge('sOc' => true) } if site_proxy.tlc.use_soc?
+      status_list
+    end
+
+    def buffered_status_timeout
+      RSMP::Validator.get_config('timeouts', 'ready') +
+        RSMP::Validator.get_config('timeouts', 'status_update') + 1
+    end
+
+    def subscribe_buffered_status(component)
+      with_site(:connected, core: '>=3.1.4') do |site_proxy|
+        status_list = buffered_status_list(site_proxy)
+        site_proxy.subscribe_to_status_and_collect(
+          status_list,
+          component: component,
+          within: RSMP::Validator.get_config('timeouts', 'status_update')
+        ).value!
+        status_list
+      end
+    end
+
+    def simulate_status_buffer_disruption
+      RSMP::Validator::SiteTester.instance.stop 'Simulating communication disruption'
+      Async::Task.current.sleep 1.5
+      Time.now.utc
+    end
+
+    def collect_status_after_reconnect(component, status_list)
+      with_site(:connected,
+                core: '>=3.1.4',
+                'collect' => {
+                  filter: RSMP::Filter.new(type: 'StatusUpdate',
+                                           component: component,
+                                           ingoing: true,
+                                           outgoing: false),
+                  timeout: buffered_status_timeout,
+                  num: 1,
+                  ingoing: true
+                }) do |site_proxy|
+        collector = site_proxy.collector
+        messages = collector.wait!
+        update = messages.first
+
+        unsubscribe_list = status_list.map { |item| item.slice('sCI', 'n') }
+        site_proxy.unsubscribe_to_status! unsubscribe_list, component: component
+        update
+      end
+    end
+
+    def collect_buffered_status_after_disruption
+      collect_buffered_status_after_disruption_with_timing[:update]
+    end
+
+    def collect_buffered_status_after_disruption_with_timing
+      component = RSMP::Validator.get_config('main_component')
+      status_list = subscribe_buffered_status component
+      reconnect_started_at = simulate_status_buffer_disruption
+      update = collect_status_after_reconnect component, status_list
+      { update: update, reconnect_started_at: reconnect_started_at }
+    end
+
+    # Verify that a site sends buffered status messages after communication is restored.
+    #
+    # 1. Given the site is connected and a status subscription is active
+    # 2. When communication is disrupted long enough for a status update to be due
+    # 3. And communication is restored
+    # 4. Then the site should send the buffered status update
+    it 'sends buffered status messages after communication is restored' do
+      skip 'requires core >= 3.1.4' unless RSMP::Validator.core_matches?('>=3.1.4')
+
+      update = collect_buffered_status_after_disruption
+
+      expect(update).to be_a(RSMP::StatusUpdate)
+      assert(!update.attributes['sS'].empty?, 'expected buffered status update to include status values')
+    end
+
+    # Verify that buffered status messages use quality "old" for core versions
+    # where the core spec requires it.
+    #
+    # 1. Given the site is connected using core 3.2.0 or later
+    # 2. And a status subscription is active
+    # 3. When communication is disrupted and later restored
+    # 4. Then buffered status values should have q=old
+    it 'marks buffered status values as old for rsmp 3.2.0 and later' do
+      skip 'requires core >= 3.2.0' unless RSMP::Validator.core_matches?('>=3.2.0')
+
+      update = collect_buffered_status_after_disruption
+
+      expect(update.attributes['sS'].map { |status| status['q'] }.uniq).to be == ['old']
+    end
+
+    # Verify that buffered status timestamps reflect when the status data was
+    # generated, not when the buffered message was sent after reconnect.
+    #
+    # 1. Given the site is connected and a status subscription is active
+    # 2. When communication is disrupted long enough for a status update to be due
+    # 3. And communication is restored
+    # 4. Then the buffered status timestamp should be older than the reconnect
+    it 'preserves buffered status timestamps from before reconnect' do
+      skip 'requires core >= 3.1.4' unless RSMP::Validator.core_matches?('>=3.1.4')
+
+      result = collect_buffered_status_after_disruption_with_timing
+      status_time = Time.parse(result[:update].attributes['sTs'])
+
+      assert(status_time < result[:reconnect_started_at],
+             "expected buffered status timestamp #{status_time} to be before reconnect " \
+             "#{result[:reconnect_started_at]}")
+    end
+  end
+end

data/test/site/tlc/alarm_spec.rb

@@ -86,7 +86,7 @@ describe 'Site::Tlc::Alarm' do
                                    timeout: timeout).collect!
         end
 
-        site_proxy.send_message RSMP::AlarmAcknowledge.new(
+        site_proxy.send_message! RSMP::AlarmAcknowledge.new(
           'cId' => component_id,
           'aTs' => site_proxy.clock.to_s,
           'aCId' => alarm_code_id
@@ -113,21 +113,21 @@ describe 'Site::Tlc::Alarm' do
       _, component_id = find_alarm_programming(alarm_code_id)
 
       # first resume alarm to make sure something happens when we suspend
-      site_proxy.resume_alarm Async::Task.current, c_id: component_id, a_c_id: alarm_code_id, collect: false
+      site_proxy.resume_alarm!(c_id: component_id, a_c_id: alarm_code_id, collect: false)
 
       begin
         # suspend alarm
-        _, response = site_proxy.suspend_alarm Async::Task.current, c_id: component_id, a_c_id: alarm_code_id,
-                                                                    collect: true
+        exchange = site_proxy.suspend_alarm!(c_id: component_id, a_c_id: alarm_code_id, collect: true)
+        response = exchange.messages.first
         expect(response).to be_a(RSMP::AlarmSuspended)
 
         # resume alarm
-        _, response = site_proxy.resume_alarm Async::Task.current, c_id: component_id, a_c_id: alarm_code_id,
-                                                                   collect: true
+        exchange = site_proxy.resume_alarm!(c_id: component_id, a_c_id: alarm_code_id, collect: true)
+        response = exchange.messages.first
         expect(response).to be_a(RSMP::AlarmResumed)
       ensure
         # always end with resuming alarm
-        site_proxy.resume_alarm Async::Task.current, c_id: component_id, a_c_id: alarm_code_id, collect: false
+        site_proxy.resume_alarm!(c_id: component_id, a_c_id: alarm_code_id, collect: false)
       end
     end
   end

data/test/site/tlc/clock_spec.rb

@@ -19,7 +19,7 @@ describe 'Site::Tlc::Clock' do
   it 'can be read with S0096' do
     with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
       site_proxy.request_status_and_collect({ S0096: %i[year month day hour minute second] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
@@ -31,7 +31,7 @@ describe 'Site::Tlc::Clock' do
   it 'can be set with M0104' do
     with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
       timeout = RSMP::Validator.get_config('timeouts', 'command_response')
-      site_proxy.tlc.set_clock(clock, within: timeout)
+      site_proxy.tlc.set_clock!(clock, within: timeout)
     end
   end
 
@@ -56,20 +56,19 @@ describe 'Site::Tlc::Clock' do
             second
           ] }
           timeout = RSMP::Validator.get_config('timeouts', 'status_update')
-          collector = site_proxy.request_status_and_collect(
+          exchange = site_proxy.request_status_and_collect(
             status_list,
             within: timeout
-          )
-          collector.ok!
-          status = status_list.keys.first.to_s
+          ).value!
+          values = exchange.reached.to_h { |item| [item['n'], item['s']] }
 
           received = Time.new(
-            collector.matcher_result({ 'sCI' => status, 'n' => 'year' })['s'],
-            collector.matcher_result({ 'sCI' => status, 'n' => 'month' })['s'],
-            collector.matcher_result({ 'sCI' => status, 'n' => 'day' })['s'],
-            collector.matcher_result({ 'sCI' => status, 'n' => 'hour' })['s'],
-            collector.matcher_result({ 'sCI' => status, 'n' => 'minute' })['s'],
-            collector.matcher_result({ 'sCI' => status, 'n' => 'second' })['s'],
+            values.fetch('year'),
+            values.fetch('month'),
+            values.fetch('day'),
+            values.fetch('hour'),
+            values.fetch('minute'),
+            values.fetch('second'),
             'UTC'
           )
 
@@ -106,12 +105,11 @@ describe 'Site::Tlc::Clock' do
           ] }
 
           timeout = RSMP::Validator.get_config('timeouts', 'status_response')
-          collector = site_proxy.request_status_and_collect(status_list,
-                                                            within: timeout)
-          collector.ok!
+          exchange = site_proxy.request_status_and_collect(status_list,
+                                                           within: timeout).value!
 
           max_diff = RSMP::Validator.get_config('timeouts', 'command_response') + timeout
-          diff = Time.parse(collector.messages.first.attributes['sTs']) - clock
+          diff = Time.parse(exchange.messages.first.attributes['sTs']) - clock
           diff = diff.round
           assert(diff.abs <= max_diff,
                  "Timestamp of S0096 is off by #{diff}s, should be within #{max_diff}s")
@@ -135,9 +133,9 @@ describe 'Site::Tlc::Clock' do
         with_clock_set site_proxy, clock, within: RSMP::Validator.get_config('timeouts', 'command_response') do
           component = RSMP::Validator.get_config('main_component')
           timeout = RSMP::Validator.get_config('timeouts', 'status_response')
-          collector = site_proxy.request_aggregated_status_and_collect(component, within: timeout)
+          exchange = site_proxy.request_aggregated_status_and_collect(component, within: timeout).value!
           max_diff = RSMP::Validator.get_config('timeouts', 'command_response') + timeout
-          diff = Time.parse(collector.messages.first.attributes['aSTS']) - clock
+          diff = Time.parse(exchange.messages.first.attributes['aSTS']) - clock
           diff = diff.round
           assert(diff.abs <= max_diff,
                  "Timestamp of aggregated status is off by #{diff}s, should be within #{max_diff}s")
@@ -158,10 +156,9 @@ describe 'Site::Tlc::Clock' do
       site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
         timeout = RSMP::Validator.get_config('timeouts', 'command_response')
         with_clock_set site_proxy, clock, within: timeout do
-          result = site_proxy.tlc.set_functional_position('NormalControl', within: timeout)
-          collector = result[:collector]
+          exchange = site_proxy.tlc.set_functional_position!('NormalControl', within: timeout)
           max_diff = timeout * 2
-          diff = Time.parse(collector.messages.first.attributes['cTS']) - clock
+          diff = Time.parse(exchange.messages.first.attributes['cTS']) - clock
           diff = diff.round
           assert(diff.abs <= max_diff,
                  "Timestamp of command response is off by #{diff}s, should be within #{max_diff}s")
@@ -182,10 +179,9 @@ describe 'Site::Tlc::Clock' do
       site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
         timeout = RSMP::Validator.get_config('timeouts', 'command_response')
         with_clock_set site_proxy, clock, within: timeout do
-          result = site_proxy.tlc.set_functional_position('NormalControl', within: timeout)
-          collector = result[:collector]
+          exchange = site_proxy.tlc.set_functional_position!('NormalControl', within: timeout)
           max_diff = timeout
-          diff = Time.parse(collector.messages.first.attributes['cTS']) - clock
+          diff = Time.parse(exchange.messages.first.attributes['cTS']) - clock
           diff = diff.round
           assert(diff.abs <= max_diff,
                  "Timestamp of command response is off by #{diff}s, should be within #{max_diff}s")
@@ -236,8 +232,12 @@ describe 'Site::Tlc::Clock' do
         with_clock_set site_proxy, clock, within: RSMP::Validator.get_config('timeouts', 'command_response') do
           log 'Checking watchdog timestamp'
           watchdog_timeout = RSMP::Validator.get_config('timeouts', 'watchdog')
-          collector = RSMP::Collector.new(site_proxy, task: Async::Task.current, type: 'Watchdog', num: 1,
-                                                      timeout: watchdog_timeout)
+          collector = RSMP::Collector.new(
+            site_proxy,
+            filter: RSMP::Filter.new(type: 'Watchdog'),
+            num: 1,
+            timeout: watchdog_timeout
+          )
           collector.collect!
           max_diff = RSMP::Validator.get_config('timeouts', 'command_response') +
                      RSMP::Validator.get_config('timeouts', 'status_response')

data/test/site/tlc/detector_logics_spec.rb

@@ -10,7 +10,7 @@ describe 'Site::Tlc::DetectorLogics' do
   it 'list size is read with S0016' do
     with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
       site_proxy.request_status_and_collect({ S0016: [:number] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
@@ -22,7 +22,7 @@ describe 'Site::Tlc::DetectorLogics' do
   it 'status is read with S0002' do
     with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
       site_proxy.request_status_and_collect({ S0002: [:detectorlogicstatus] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
@@ -34,7 +34,7 @@ describe 'Site::Tlc::DetectorLogics' do
   it 'forcing is read with S0021' do
     with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
       site_proxy.request_status_and_collect({ S0021: [:detectorlogics] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
@@ -45,14 +45,14 @@ describe 'Site::Tlc::DetectorLogics' do
     with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
       RSMP::Validator.get_config('components', 'detector_logic').keys.each_with_index do |component, indx|
         timeout = RSMP::Validator.get_config('timeouts', 'command_response')
-        site_proxy.tlc.force_detector_logic(component, status: 'True', mode: 'True', within: timeout)
+        site_proxy.tlc.force_detector_logic!(component, status: 'True', mode: 'True', within: timeout)
         wait_for_status(
           site_proxy,
           "detector logic #{component} to be True",
           [{ 'sCI' => 'S0002', 'n' => 'detectorlogicstatus', 's' => /^.{#{indx}}1/ }]
         )
 
-        site_proxy.tlc.force_detector_logic(component, status: 'True', mode: 'False', within: timeout)
+        site_proxy.tlc.force_detector_logic!(component, status: 'True', mode: 'False', within: timeout)
         wait_for_status(
           site_proxy,
           "detector logic #{component} to be False",
@@ -70,7 +70,7 @@ describe 'Site::Tlc::DetectorLogics' do
   it 'sensitivity is read with S0031' do
     with_site(:connected, sxl: '>=1.0.15') do |site_proxy|
       site_proxy.request_status_and_collect({ S0031: [:status] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 end

data/test/site/tlc/emergency_routes_spec.rb

@@ -2,27 +2,27 @@ describe 'Site::Tlc::EmergencyRoutes' do
   include RSMP::Validator::Helpers::Status
 
   # Verify that current emergency route can be read with S0006.
-  # Depreciated from 1.2, use S0035 instead.
+  # Deprecated from 1.2.0, use S0035 instead.
   # 1. Given the site_proxy is connected.
   # 2. When we request S0006.
   # 3. Then we should receive a status response.
   it 'emergency route is read with S0006' do
-    with_site(:connected, sxl: ['>=1.0.7', '<1.2']) do |site_proxy|
+    with_site(:connected, sxl: ['>=1.0.7', '<1.2.0']) do |site_proxy|
       site_proxy.request_status_and_collect({ S0006: %i[status emergencystage] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
   # Verify that current emergency routes can be read with S0035.
-  # Requires core >= 3.2 since it uses the array data type.
+  # Requires core >= 3.2.0 since it uses the array data type.
   # 1. Given the site_proxy is connected.
   # 2. When we request S0035.
   # 3. Then we should receive a status response.
   it 'emergency route is read with S0035' do
-    skip 'requires core >= 3.2' unless RSMP::Validator.core_matches?('>=3.2')
-    with_site(:connected, sxl: '>=1.2') do |site_proxy|
+    skip 'requires core >= 3.2.0' unless RSMP::Validator.core_matches?('>=3.2.0')
+    with_site(:connected, sxl: '>=1.2.0') do |site_proxy|
       site_proxy.request_status_and_collect({ S0035: [:emergencyroutes] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
@@ -32,20 +32,20 @@ describe 'Site::Tlc::EmergencyRoutes' do
   # 2. When we send M0005 to set emergency route.
   # 3. Then we should get a command responds confirming the change.
   it 'can be activated with M0005 and read with S0006' do
-    skip 'requires sxl >= 1.0.7, < 1.2' unless RSMP::Validator.sxl_matches?(['>=1.0.7', '<1.2'])
+    skip 'requires sxl >= 1.0.7, < 1.2.0' unless RSMP::Validator.sxl_matches?(['>=1.0.7', '<1.2.0'])
     emergency_routes = RSMP::Validator.get_config('items', 'emergency_routes')
     skip('No emergency routes configured') if emergency_routes.nil? || emergency_routes.empty?
 
     def set_emergency_states(site_proxy, emergency_routes, state)
       timeout = RSMP::Validator.get_config('timeouts', 'command_response')
       emergency_routes.each do |emergency_route|
-        site_proxy.tlc.set_emergency_route(route: emergency_route.to_s, active: state, within: timeout)
+        site_proxy.tlc.set_emergency_route!(route: emergency_route.to_s, active: state, within: timeout)
       end
       wait_for_status(site_proxy, "emergency route #{emergency_routes.last} to be enabled",
                       [
-                        { 'sCI' => 'S0006', 'n' => 'status', 's' => (state ? 'True' : 'False') },
+                        { 'sCI' => 'S0006', 'n' => 'status', 's' => state },
                         { 'sCI' => 'S0006', 'n' => 'emergencystage',
-                          's' => (state ? emergency_routes.last.to_s : '0') }
+                          's' => (state ? emergency_routes.last.to_i : 0) }
                       ])
     end
 
@@ -68,8 +68,8 @@ describe 'Site::Tlc::EmergencyRoutes' do
   # 5. Then we should receive the list of active routes.
 
   it 'emergency routes can be activated with M0005 and read with S0035' do
-    skip 'requires core >= 3.2' unless RSMP::Validator.core_matches?('>=3.2')
-    skip 'requires sxl >= 1.2' unless RSMP::Validator.sxl_matches?('>=1.2')
+    skip 'requires core >= 3.2.0' unless RSMP::Validator.core_matches?('>=3.2.0')
+    skip 'requires sxl >= 1.2.0' unless RSMP::Validator.sxl_matches?('>=1.2.0')
 
     emergency_routes = RSMP::Validator.get_config('items', 'emergency_routes')
     skip('No emergency routes configured') if emergency_routes.nil? || emergency_routes.empty?
@@ -77,16 +77,16 @@ describe 'Site::Tlc::EmergencyRoutes' do
     def enable_routes(site_proxy, emergency_routes)
       timeout = RSMP::Validator.get_config('timeouts', 'command_response')
       emergency_routes.each do |emergency_route|
-        site_proxy.tlc.set_emergency_route(route: emergency_route.to_s, active: true, within: timeout)
+        site_proxy.tlc.set_emergency_route!(route: emergency_route.to_s, active: true, within: timeout)
       end
-      routes = emergency_routes.map { |i| { 'id' => i.to_s } }
+      routes = emergency_routes.map { |i| { 'id' => i.to_i } }
       wait_for_status(site_proxy, "emergency routes #{emergency_routes} to be enabled",
                       [{ 'sCI' => 'S0035', 'n' => 'emergencyroutes', 's' => routes }])
     end
 
     def disable_routes(site_proxy, emergency_routes, within:)
       emergency_routes.each do |emergency_route|
-        site_proxy.tlc.set_emergency_route(route: emergency_route.to_s, active: false, within:)
+        site_proxy.tlc.set_emergency_route!(route: emergency_route.to_s, active: false, within:)
       end
       routes = []
       wait_for_status(site_proxy, 'all emergency routes to be disabled',

data/test/site/tlc/input_spec.rb

@@ -8,11 +8,11 @@ describe 'Site::Tlc::Input' do
   # 2. When we read input with S0029
   # 3. Then we should receive a valid response
   it 'is read with S0003 with extended input status' do
-    with_site(:connected, sxl: '<1.2') do |site_proxy|
+    with_site(:connected, sxl: '<1.2.0') do |site_proxy|
       site_proxy.request_status_and_collect(
         { S0003: %i[inputstatus extendedinputstatus] },
         within: RSMP::Validator.get_config('timeouts', 'status_response')
-      ).ok!
+      ).value!
     end
   end
 
@@ -21,9 +21,9 @@ describe 'Site::Tlc::Input' do
   # 2. When we read input with S0029
   # 3. Then we should receive a valid response
   it 'is read with S0003' do
-    with_site(:connected, sxl: '>=1.2') do |site_proxy|
+    with_site(:connected, sxl: '>=1.2.0') do |site_proxy|
       site_proxy.request_status_and_collect({ S0003: [:inputstatus] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
@@ -34,7 +34,7 @@ describe 'Site::Tlc::Input' do
   it 'forcing is read with S0029' do
     with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
       site_proxy.request_status_and_collect({ S0029: [:status] },
-                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
     end
   end
 
@@ -50,10 +50,10 @@ describe 'Site::Tlc::Input' do
       skip('No inputs configured') if inputs.nil? || inputs.empty?
       inputs.each do |input|
         timeout = RSMP::Validator.get_config('timeouts', 'command')
-        site_proxy.tlc.force_input(input: input, status: 'True', value: 'False', within: timeout)
-        site_proxy.tlc.force_input(input: input, status: 'True', value: 'True', within: timeout)
+        site_proxy.tlc.force_input!(input: input, status: 'True', value: 'False', within: timeout)
+        site_proxy.tlc.force_input!(input: input, status: 'True', value: 'True', within: timeout)
       ensure
-        site_proxy.tlc.force_input(input: input, status: 'False', value: 'True', within: timeout)
+        site_proxy.tlc.force_input!(input: input, status: 'False', value: 'True', within: timeout)
       end
     end
   end
@@ -84,7 +84,7 @@ describe 'Site::Tlc::Input' do
       skip('No inputs configured') if inputs.nil? || inputs.empty?
       status = '1,3,12;5,5,10'
       timeout = RSMP::Validator.get_config('timeouts', 'command')
-      site_proxy.tlc.set_inputs(status, within: timeout)
+      site_proxy.tlc.set_inputs!(status, within: timeout)
     end
   end
 
@@ -96,7 +96,7 @@ describe 'Site::Tlc::Input' do
     with_site(:connected, sxl: '>=1.0.15') do |site_proxy|
       timeout = RSMP::Validator.get_config('timeouts', 'command_response')
       status = '1-50'
-      site_proxy.tlc.set_trigger_level(status, within: timeout)
+      site_proxy.tlc.set_trigger_level!(status, within: timeout)
     end
   end
 end