rsmp-validator 0.1.0

data/test/site/tlc/output_spec.rb

@@ -0,0 +1,58 @@
+describe 'Site::Tlc::Output' do
+  # Tests related to outputs.
+
+  # Verify that  output status can be read with S0004, extended output status
+  # 1. Given the site is connected
+  # 2. When we subscribe to S0004
+  # 3. We should receive a status updated
+  # 4. And the outputstatus attribute should be a digit string
+  it 'is read with S0004 with extended output status' do
+    with_site(:connected, sxl: ['>=1.0.7', '<1.2']) do |site_proxy|
+      site_proxy.request_status_and_collect(
+        { S0004: %i[outputstatus extendedoutputstatus] },
+        within: RSMP::Validator.get_config('timeouts', 'status_response')
+      ).ok!
+    end
+  end
+
+  # Verify that  output status can be read with S0004
+  # 1. Given the site is connected
+  # 2. When we subscribe to S0004
+  # 3. We should receive a status updated
+  # 4. And the outputstatus attribute should be a digit string
+  it 'is read with S0004' do
+    with_site(:connected, sxl: ['>=1.2']) do |site_proxy|
+      site_proxy.request_status_and_collect({ S0004: [:outputstatus] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that forced output status can be read with S0030
+  # 1. Given the site is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'forcing is read with S0030' do
+    with_site(:connected, sxl: '>=1.0.15') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0030: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that output can be forced with M0020
+  # 1. Given the site is connected
+  # 2. When we force output with M0020
+  # 3. Wait for status = true
+  it 'forcing is set with M0020' do
+    with_site(:connected, sxl: '>=1.0.15') do |site_proxy|
+      outputs = RSMP::Validator.get_config('items', 'outputs')
+      skip('No outputs configured') if outputs.nil? || outputs.empty?
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      outputs.each do |output|
+        site_proxy.tlc.force_output(output: output, status: 'True', value: 'True', within: timeout)
+        site_proxy.tlc.force_output(output: output, status: 'True', value: 'False', within: timeout)
+      ensure
+        site_proxy.tlc.force_output(output: output, status: 'False', value: 'True', within: timeout)
+      end
+    end
+  end
+end

data/test/site/tlc/signal_groups_spec.rb

@@ -0,0 +1,96 @@
+describe 'Site::Tlc::SignalGroups' do
+  include RSMP::Validator::Helpers::Startup
+
+  # Validate that a signal group can be ordered to green using the M0010 command.
+  #
+  # 1. Verify connection
+  # 2. Send control command to start signalgrup, set_signal_start= true, include security_code
+  # 3. Wait for status = true
+  it 'is ordered to green with M0010' do
+    with_site(:connected, sxl: '>=1.0.8') do |site_proxy|
+      component = RSMP::Validator.get_config('components', 'signal_group').keys[0]
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.order_signal_start(component, within: timeout)
+    end
+  end
+
+  # 1. Verify connection
+  # 2. Send control command to stop signalgrup, set_signal_start= false, include security_code
+  # 3. Wait for status = true
+  it 'is ordered to red with M0011' do
+    with_site(:connected, sxl: '>=1.0.8') do |site_proxy|
+      component = RSMP::Validator.get_config('components', 'signal_group').keys[0]
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.order_signal_stop(component, within: timeout)
+    end
+  end
+
+  # Verify that signal group status can be read with S0001.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'state is read with S0001' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.request_status_and_collect(
+        { S0001: %i[signalgroupstatus cyclecounter basecyclecounter stage] },
+        within: RSMP::Validator.get_config('timeouts', 'status_response')
+      ).ok!
+    end
+  end
+
+  # Verify that time-of-green/time-of-red can be read with S0025.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'red/green predictions is read with S0025' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      component = RSMP::Validator.get_config('components', 'signal_group').keys.first
+      site_proxy.request_status_and_collect(
+        { S0025: %i[
+          minToGEstimate
+          maxToGEstimate
+          likelyToGEstimate
+          ToGConfidence
+          minToREstimate
+          maxToREstimate
+          likelyToREstimate
+        ] },
+        component: component,
+        within: RSMP::Validator.get_config('timeouts', 'status_response')
+      ).ok!
+    end
+  end
+
+  # Verify status S0017 number of signal groups
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'list size is read with S0017' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0017: [:number] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we can activate normal control after yellow flash mode is turned off
+  #
+  # 1. Given the site_proxy is connected and in yellow flash mode
+  # 2. When we activate normal control
+  # 3. All signal groups should go through e, f and g
+  it 'follow startup sequence after yellow flash' do
+    skip 'requires sxl >= 1.0.7' unless RSMP::Validator.sxl_matches?('>=1.0.7')
+    with_site(:connected) do |site_proxy|
+      verify_startup_sequence(site_proxy) do
+        timeout = RSMP::Validator.get_config('timeouts', 'yellow_flash')
+        site_proxy.tlc.set_functional_position('YellowFlash', within: timeout)
+        command_timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+        site_proxy.tlc.set_functional_position('NormalControl', within: command_timeout)
+      end
+      command_timeout ||= RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.set_functional_position('NormalControl', within: command_timeout)
+    end
+  end
+end

data/test/site/tlc/signal_plans_spec.rb

@@ -0,0 +1,287 @@
+describe 'Site::Tlc::SignalPlans' do
+  include RSMP::Validator::Helpers::SignalPlans
+
+  # Verify status S0014 current time plan
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'currently active is read with S0014' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      status_list = if RSMP::Proxy.version_meets_requirement?(site_proxy.sxl_version, '>=1.1')
+                      { S0014: %i[status source] }
+                    else
+                      { S0014: [:status] }
+                    end
+      site_proxy.request_status_and_collect(status_list,
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we change time plan (signal program)
+  # We try switching all programs configured
+  #
+  # 1. Given the site_proxy is connected
+  # 2. And there is a RSMP::Validator.get_config('validator') with a time plan
+  # 3. When we send the command
+  # 3. We should receive a confirmative command response before timeout
+  it 'currently active is set with M0002' do
+    skip 'requires sxl >= 1.0.7' unless RSMP::Validator.sxl_matches?('>=1.0.7')
+    plans = RSMP::Validator.get_config('items', 'plans')
+    skip('No time plans configured') if plans.nil? || plans.empty?
+    with_site(:connected) do |site_proxy|
+      RSMP::Validator.get_config('secrets', 'security_codes', 2)
+      plans.each do |plan|
+        command_timeout = RSMP::Validator.get_config('timeouts', 'command')
+        status_timeout = RSMP::Validator.get_config('timeouts', 'status_response')
+        site_proxy.tlc.set_timeplan(plan, within: command_timeout)
+
+        s0014_fields = if RSMP::Proxy.version_meets_requirement?(site_proxy.sxl_version, '>=1.1')
+                         { S0014: %i[status source] }
+                       else
+                         { S0014: [:status] }
+                       end
+        collector = site_proxy.request_status_and_collect(
+          s0014_fields,
+          within: status_timeout
+        )
+        collector.ok!
+        ss = collector.messages.last.attributes['sS']
+        expect(ss.find { |i| i['n'] == 'status' }&.fetch('s').to_i).to eq(plan)
+      end
+    end
+  end
+
+  # Verify status S0018 number of time plans
+  # Deprecated from 1.2, use S0022 instead.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'list size is read with S0018' do
+    with_site(:connected, sxl: ['>=1.0.7', '<1.2']) do |site_proxy|
+      site_proxy.request_status_and_collect({ S0018: [:number] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0022 list of time plans
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'list is read with S0022' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0022: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0026 week time table
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'week table is read with S0026' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0026: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we can set week table with M0016
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send the command
+  # 3. We should receive a confirmative command response before timeout
+  it 'week table is set with M0016' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      status = '0-1,6-2'
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.set_week_table(status, within: timeout)
+    end
+  end
+
+  # Verify status S0027 time tables
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'day table is read with S0027' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0027: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we can set day table with M0017
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send the command
+  # 3. We should receive a confirmative command response before timeout
+  it 'day table is set with M0017' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      status = '12-1-12-59,1-0-23-12'
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.set_day_table(status, within: timeout)
+    end
+  end
+
+  # Verify status S0097 version of traffic program
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'version is read with S0097' do
+    with_site(:connected, sxl: '>=1.0.15') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0097: %i[timestamp checksum] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  #
+  # Verify status S0098 configuration of traffic parameters
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'config is read with S0098' do
+    with_site(:connected, sxl: '>=1.0.15') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'status_response')
+      collector = site_proxy.request_status_and_collect(
+        { S0098: %i[timestamp config version] },
+        within: timeout
+      )
+      collector.ok!
+      ss = collector.messages.last.attributes['sS']
+      values = ss.to_h { |i| [i['n'], i['s']] }
+
+      assert(!values['timestamp'].empty?, 'expected timestamp to not be empty')
+      assert(!values['config'].empty?, 'expected config to not be empty')
+      assert(!values['version'].empty?, 'expected version to not be empty')
+    end
+  end
+
+  # Verify status S0023 command table
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'dynamic bands are read with S0023' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0023: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that dynamic bands can the set with M0014
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send the command
+  # 3. We should receive a confirmative command response before timeout
+  it 'dynamic bands are set with M0014' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      plan = RSMP::Validator.get_config('items', 'plans').first
+      status = '1-12'
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.set_dynamic_bands(plan: plan, status: status, within: timeout)
+    end
+  end
+
+  # Verify that dynamic bands can be read and changed
+  #
+  # 1. Given the site_proxy is connected
+  # 2. And we read dynamic band
+  # 3. When we set dynamic band to 2x previous value
+  # 4. Then reading dynamic bands should confirm the change
+  # 5. Finally when we revert dynamic band to previous value
+  # 6. Then reading dynamic bands should confirm the reversion
+
+  it 'dynamic bands values can be changed and read back' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      plan = RSMP::Validator.get_config('items', 'plans').first
+      band = 3
+
+      value = site_proxy.tlc.read_dynamic_band(plan: plan, band: band) || 0
+      expect(value).to be_a(Integer)
+
+      new_value = value + 1
+
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.set_dynamic_bands(plan: plan, status: "#{band}-#{new_value}", within: timeout)
+      expect(site_proxy.tlc.read_dynamic_band(plan: plan, band: band)).to eq(new_value)
+
+      site_proxy.tlc.set_dynamic_bands(plan: plan, status: "#{band}-#{value}", within: timeout)
+      expect(site_proxy.tlc.read_dynamic_band(plan: plan, band: band)).to eq(value)
+    end
+  end
+
+  # Verify command M0023 timeout of dynamic bands
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send command to set timeout
+  # 3. Then we should get a confirmation
+  # 2. When we send command to disable timeout
+  # 3. Then we should get a confirmation
+  it 'timeout for dynamic bands is set with M0023' do
+    with_site(:connected, sxl: '>=1.1') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      status = 10
+      site_proxy.tlc.set_dynamic_bands_timeout(status, within: timeout)
+      status = 0
+      site_proxy.tlc.set_dynamic_bands_timeout(status, within: timeout)
+    end
+  end
+
+  # Verify status S0024 offset time
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'offset is read with S0024' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0024: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # 1. Verify connection
+  # 2. Send control command to set dynamic_bands
+  # 3. Wait for status = true
+  it 'offset is set with M0015' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      plan = RSMP::Validator.get_config('items', 'plans').first
+      offset = 99
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.tlc.set_offset(plan: plan, offset: offset, within: timeout)
+    end
+  end
+
+  # Verify status S0028 cycle time
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request the status
+  # 3. We should receive a status response before timeout
+  it 'cycle time is read with S0028' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0028: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that cycle time can be changed with M0018
+  #
+  # 1. Given the site_proxy is connected
+  # 2. And we read cycle times
+  # 3. When we extend cycle time of curent plan with 5s
+  # 4. Then reading the cycle time should confirm the change
+  # 5. Finally when we revert cycle time to previous value
+  # 6. Then reading cycle time should confirm the reversion
+  it 'cycle time is set with M0018' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      with_cycle_time_extended(site_proxy) do
+        log 'Cycle time extension confirmed'
+      end
+    end
+  end
+end

data/test/site/tlc/signal_priority_spec.rb

@@ -0,0 +1,144 @@
+describe 'Site::Tlc::SignalPriority' do
+  include RSMP::Validator::Helpers::Status
+
+  # Signal requests require core >= 3.2 because they uses the Array data type.
+
+  # Validate that a signal priority can be requested.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send a signal priority request
+  # 3. Then we should receive an acknowledgement
+  it 'can be requested with M0022' do
+    with_site(:connected, core: '>=3.2', sxl: '>=1.1') do |site_proxy|
+      signal_group = RSMP::Validator.get_config('components', 'signal_group').keys.first
+      command_list = RSMP::CommandList.new(:M0022, :requestPriority,
+                                           requestId: SecureRandom.uuid[0..3],
+                                           signalGroupId: signal_group,
+                                           type: 'new',
+                                           level: 7,
+                                           eta: 10,
+                                           vehicleType: 'car').to_a
+      log "Request signal priority for signal group #{signal_group}"
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      site_proxy.send_command_and_collect(command_list, within: timeout).ok!
+    end
+  end
+
+  # Validate that signal priority status can be requested.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we request signal priority status
+  # 3. Then we should receive a status update
+  it 'status can be fetched with S0033' do
+    with_site(:connected, core: '>=3.2', sxl: '>=1.1') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0033: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Validate that we can subscribe signal priority status
+  #
+  # 1. Given the site_proxy is connected
+  # 2. And we subscribe to signal priority status updates
+  # 4. Then we should receive an acknowledgement
+  # 5. And we should reive a status updates
+  it 'status can be subscribed to with S0033' do
+    with_site(:connected, core: '>=3.2', sxl: '>=1.1') do |site_proxy|
+      status_list = [{ 'sCI' => 'S0033', 'n' => 'status', 'uRt' => '0' }]
+      status_list.map! { |item| item.merge!('sOc' => true) } if site_proxy.tlc.use_soc?
+      wait_for_status(site_proxy, 'signal priority status', status_list)
+    end
+  end
+
+  # Validate that a signal priority completes when we cancel it.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. And we subscribe to signal priority status
+  # 3. When we send a signal priority request
+  # 4. Then the request state should become 'received'
+  # 5. Then the request state should become 'activated'
+  # 6. When we cancel the request
+  # 7. Then the state should become 'completed'
+
+  it 'becomes completed when cancelled' do
+    with_site(:connected, core: '>=3.2', sxl: '>=1.1') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'priority_completion')
+      component = RSMP::Validator.get_config('main_component')
+      signal_group_id = RSMP::Validator.get_config('components', 'signal_group').keys.first
+      prio = RSMP::Validator::Helpers::SignalPriority::RequestHelper.new(
+        site_proxy,
+        component: component,
+        signal_group_id: signal_group_id,
+        timeout: timeout,
+        task: Async::Task.current
+      )
+
+      prio.run do
+        log 'Before: Send unrelated signal priority request.'
+        prio.request_unrelated
+
+        log 'Send signal priority request, wait for reception.'
+        prio.request
+
+        log 'After: Send unrelated signal priority request.'
+        prio.request_unrelated
+
+        prio.expect :received
+        log 'Signal priority request was received, wait for activation.'
+
+        prio.expect :activated
+        log 'Signal priority request was activated, now cancel it and wait for completion.'
+
+        prio.cancel
+        prio.expect :completed
+        log 'Signal priority request was completed.'
+      end
+    end
+  end
+
+  # Validate that a signal priority times out if not cancelled.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. And we subscribe to signal priority status
+  # 3. When we send a signal priority request
+  # 4. Then the request state should become 'received'
+  # 5. Then the request state should become 'activated'
+  # 6. When we do not cancel the request
+  # 7. Then the state should become 'stale'
+
+  it 'becomes stale if not cancelled' do
+    with_site(:connected, core: '>=3.2', sxl: '>=1.1') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'priority_completion')
+      component = RSMP::Validator.get_config('main_component')
+      signal_group_id = RSMP::Validator.get_config('components', 'signal_group').keys.first
+      prio = RSMP::Validator::Helpers::SignalPriority::RequestHelper.new(
+        site_proxy,
+        component: component,
+        signal_group_id: signal_group_id,
+        timeout: timeout,
+        task: Async::Task.current
+      )
+
+      prio.run do
+        log 'Before: Send unrelated signal priority request.'
+        prio.request_unrelated
+
+        log 'Send signal priority request, wait for reception.'
+        prio.request
+
+        log 'After: Send unrelated signal priority request.'
+        prio.request_unrelated
+
+        prio.expect :received
+        log 'Signal priority request was received, wait for activation.'
+
+        prio.expect :activated
+        log 'Signal priority request was activated, wait for it to become stale.'
+
+        # don't cancel request, it should then become stale by itself
+        prio.expect :stale
+        log 'Signal priority request became stale.'
+      end
+    end
+  end
+end

data/test/site/tlc/subscribe_spec.rb

@@ -0,0 +1,71 @@
+describe 'Site::Tlc::Subscribe' do
+  # Check that we can *subscribe* to status messages.
+  # The test subscribes to S0001 (signal group status), because
+  # it will usually change once per second, but otherwise the choice
+  # is arbitrary as we simply want to check that
+  # the subscription mechanism works.
+  #
+  # 1. subscribe
+  # 1. check that we receive a status update with a predefined time
+  # 1. unsubscribe
+
+  it 'can be turned on and off for S0001' do
+    with_site(:connected) do |site_proxy|
+      log 'Subscribe to status and wait for update'
+      component = RSMP::Validator.get_config('main_component')
+
+      status_list = [{ 'sCI' => 'S0001', 'n' => 'signalgroupstatus', 'uRt' => '1' }]
+      status_list.map! { |item| item.merge!('sOc' => true) } if site_proxy.tlc.use_soc?
+
+      site_proxy.subscribe_to_status_and_collect(status_list,
+                                                 component: component,
+                                                 within: RSMP::Validator.get_config('timeouts', 'status_update')).ok!
+    ensure
+      unsubscribe_list = status_list.map { |item| item.slice('sCI', 'n') }
+      site_proxy.unsubscribe_to_status unsubscribe_list, component: component
+    end
+  end
+
+  # Check that we can change the update rate interval while status subscription is active.
+  # The test subscribes to S0001 'cyclecounter' attribute with an initial update rate of 60s,
+  # then changes the update rate to 1s and verifies the new rate is in effect.
+  #
+  # 1. Subscribe to S0001 'cyclecounter' with update rate 60s
+  # 2. Verify that subscription succeeds
+  # 3. Send the same subscription again with update rate 1s
+  # 4. Verify that the new update rate is in effect by checking next update is received within 2s
+
+  it 'can change interval during active subscription' do
+    with_site(:connected) do |site_proxy|
+      component = RSMP::Validator.get_config('main_component')
+
+      # Step 1: Subscribe with 60s update rate (no need to wait for updates with long interval)
+      log 'Subscribe to S0001 cyclecounter with 60s update rate'
+      initial_status_list = [{ 'sCI' => 'S0001', 'n' => 'cyclecounter', 'uRt' => '60' }]
+      initial_status_list.map! { |item| item.merge!('sOc' => true) } if site_proxy.tlc.use_soc?
+
+      # Subscribe but don't wait for updates (since 60s is too long)
+      site_proxy.subscribe_to_status initial_status_list, component: component
+      log 'Initial subscription with 60s update rate successful'
+
+      # Step 3: Change update rate to 1s by re-subscribing and verify we get update within 2s
+      log 'Change update rate to 1s by re-subscribing and verify update within 2s'
+      updated_status_list = [{ 'sCI' => 'S0001', 'n' => 'cyclecounter', 'uRt' => '1' }]
+      updated_status_list.map! { |item| item.merge!('sOc' => true) } if site_proxy.tlc.use_soc?
+
+      # This should collect at least one status update within 2s if the 1s rate is working
+      collector = site_proxy.subscribe_to_status_and_collect(updated_status_list,
+                                                             component: component,
+                                                             within: 2).ok!
+
+      assert(!collector.nil?, 'Expected subscribe_to_status_and_collect to return a collector')
+      assert(!collector.messages.empty?,
+             'Expected to receive status update within 2s with new 1s update rate')
+      log 'Successfully received status update within 2s, confirming 1s update rate is active'
+    ensure
+      # Clean up subscription
+      unsubscribe_list = [{ 'sCI' => 'S0001', 'n' => 'cyclecounter' }]
+      site_proxy.unsubscribe_to_status unsubscribe_list, component: component
+    end
+  end
+end