rsmp-validator 0.1.0

data/test/site/core/aggregated_status_spec.rb

@@ -0,0 +1,43 @@
+describe 'Site::Core' do
+  describe 'Aggregated Status' do
+    # Verify that the controller responds to an aggregated status request.
+    #
+    # 1. Given the site is connected
+    # 2. When we request aggregated status
+    # 3. Then we should receive an aggregated status
+    it 'can be requested' do
+      with_site(:connected, core: '>=3.1.5') do |site_proxy|
+        log 'Request aggregated status'
+        site_proxy.request_aggregated_status_and_collect(
+          RSMP::Validator.get_config('main_component'),
+          within: RSMP::Validator.get_config('timeouts', 'status_response')
+        ).ok!
+      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.
+    #
+    # 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',
+                           'collect' => {
+                             filter: RSMP::Filter.new(type: 'AggregatedStatus'),
+                             timeout: RSMP::Validator.get_config('timeouts', 'ready'),
+                             num: 1,
+                             ingoing: true
+                           }) do |site_proxy|
+        collector = site_proxy.collector
+        collector.use_task Async::Task.current
+        collector.wait!
+        aggregated_status = site_proxy.collector.messages.first
+
+        expect(aggregated_status).to be_a(RSMP::AggregatedStatus)
+        expect(aggregated_status.attribute('fP')).to be_nil
+        expect(aggregated_status.attribute('fS')).to be_nil
+      end
+    end
+  end
+end

data/test/site/core/connect_spec.rb

@@ -0,0 +1,104 @@
+describe 'Site::Core' do
+  describe 'Connection Sequence' do
+    include RSMP::Validator::Helpers::Handshake
+
+    # Verify the connection sequence when using rsmp core 3.1.1
+    #
+    # 1. Given the site is connected and using core 3.1.1
+    # 2. When handshake messages are sent and received
+    # 3. Then the handshake messages should be in the specified sequence corresponding to version 3.1.1
+    # 4. And the connection sequence should be complete
+    it 'is correct for rsmp version 3.1.1' do
+      skip 'requires core == 3.1.1' unless RSMP::Validator.core_matches?('3.1.1')
+      check_sequence '3.1.1'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.1.2
+    #
+    # 1. Given the site is connected and using core 3.1.2
+    # 2. When handshake messages are sent and received
+    # 3. Then the handshake messages should be in the specified sequence corresponding to version 3.1.2
+    # 4. And the connection sequence should be complete
+    it 'is correct for rsmp version 3.1.2' do
+      skip 'requires core == 3.1.2' unless RSMP::Validator.core_matches?('3.1.2')
+      check_sequence '3.1.2'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.1.3
+    #
+    # 1. Given the site is connected and using core 3.1.3
+    # 2. When handshake messages are sent and received
+    # 3. Then the handshake messages should be in the specified sequence corresponding to version 3.1.3
+    # 4. And the connection sequence should be complete
+    it 'is correct for rsmp version 3.1.3' do
+      skip 'requires core == 3.1.3' unless RSMP::Validator.core_matches?('3.1.3')
+      check_sequence '3.1.3'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.1.4
+    #
+    # 1. Given the site is connected and using core 3.1.4
+    # 2. When handshake messages are sent and received
+    # 3. Then the handshake messages should be in the specified sequence corresponding to version 3.1.4
+    # 4. And the connection sequence should be complete
+    it 'is correct for rsmp version 3.1.4' do
+      skip 'requires core == 3.1.4' unless RSMP::Validator.core_matches?('3.1.4')
+      check_sequence '3.1.4'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.1.5
+    #
+    # 1. Given the site is connected and using core 3.1.5
+    # 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.1.5' do
+      skip 'requires core == 3.1.5' unless RSMP::Validator.core_matches?('3.1.5')
+      check_sequence '3.1.5'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.2
+    #
+    # 1. Given the site is connected and using core 3.2
+    # 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'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.2.1
+    #
+    # 1. Given the site is connected and using core 3.2.1
+    # 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.1' do
+      skip 'requires core == 3.2.1' unless RSMP::Validator.core_matches?('3.2.1')
+      check_sequence '3.2.1'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.2.2
+    #
+    # 1. Given the site is connected and using core 3.2.2
+    # 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.2' do
+      skip 'requires core == 3.2.2' unless RSMP::Validator.core_matches?('3.2.2')
+      check_sequence '3.2.2'
+    end
+
+    # Verify the connection sequence when using rsmp core 3.3.0
+    #
+    # 1. Given the site is connected and using core 3.3.0
+    # 2. When handshake messages are sent and received
+    # 3. Then ComponentList should be exchanged before application traffic
+    # 4. And the connection sequence should be complete
+    it 'is correct for rsmp version 3.3.0' do
+      skip 'requires core == 3.3.0' unless RSMP::Validator.core_matches?('3.3.0')
+      check_sequence '3.3.0'
+    end
+  end
+end

data/test/site/core/core_spec.rb

@@ -0,0 +1,9 @@
+describe 'Site' do
+  # Tests covering the core specification for sites.
+  #
+  # These tests are generic and can be used to test all types of RSMP sites.
+
+  describe 'Core' do
+    # This group is intentionally empty, but exist so for documentation generation purposes.
+  end
+end

data/test/site/core/disconnect_spec.rb

@@ -0,0 +1,54 @@
+describe 'Site::Core' do
+  # Check that the site closed the connection as required when faced with
+  # various types of incorrect behaviour from our side.
+  #
+  # The site object passed by RSMP::Validator::SiteTester a SiteProxy object. We can redefine methods
+  # on this object to modify behaviour after the connection has been established. To ensure
+  # that the modfid SityProxy is not reused in later tests, we use  RSMP::Validator::SiteTester.isolate,
+  # rather than the more common RSMP::Validator::SiteTester.connect.
+
+  describe 'Connection' do
+    # 1. Given the site has just connected
+    # 2. When our supervisor does not acknowledge watchdogs
+    # 3. Then the site should disconnect
+    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
+          end
+          site_proxy.wait_for_state :disconnected, timeout: timeout
+        end
+      rescue RSMP::TimeoutError
+        raise "Site did not disconnect within #{timeout}s"
+      end
+    end
+
+    # 1. Given the site has just connected
+    # 2. When our supervisor stops sending watchdogs
+    # 3. Then the site should not disconnect
+    it 'is not closed if watchdogs are not received' 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
+        end
+      end
+    end
+  end
+end

data/test/site/site_spec.rb

@@ -0,0 +1,5 @@
+# Tests for RSMP sites (as opposed to supervisors), like traffic light controllers.
+#
+describe 'Site' do
+  # This group is intentionally empty, but exist so for documentation generation purposes
+end

data/test/site/tlc/alarm_spec.rb

@@ -0,0 +1,134 @@
+describe 'Site::Tlc::Alarm' do
+  include RSMP::Validator::Helpers::Alarms
+
+  # Testing alarms require a reliable way of rainsing them.
+  #
+  # There's no way to trigger alarms directly via RSMP yet,
+  # but often you can program the equipment to raise an alarm
+  # when a specific input is activated. If that's the case,
+  # set the `alarm_activcation` item in the validator config to
+  # specify which input activates which alarm. See docs for details.
+  #
+  # Triggered alarms manually on the equipment is not used,
+  # because validator is meant for automated testing.
+
+  # Validate that a detector logic fault A0302 is raises and cleared.
+  #
+  # The test requires that the device is programmed so that the alarm
+  # is raise when a specific input is activated, as specified in the
+  # test configuration.
+  #
+  # 1. Given the site is connected
+  # 2. When we force the input to True
+  # 3. Then an alarm should be raised, with a timestamp close to now
+  # 4. When we force the input to False
+  # 5. Then the alarm issue should become inactive, with a timestamp close to now
+
+  it 'raises A0302 when input is activated' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      alarm_code_id = 'A0302'
+      def verify_timestamp(alarm, duration = 1.minute)
+        alarm_time = Time.parse(alarm.attributes['aTs'])
+        expect(alarm_time).to be_within(duration).of(Time.now.utc)
+      end
+      # Raise alarm by activating input
+      deactivated, component_id = with_alarm_activated(site_proxy, alarm_code_id) do |alarm, component_id|
+        verify_timestamp alarm
+        log "Alarm #{alarm_code_id} is now Active on component #{component_id}"
+      end
+      verify_timestamp deactivated
+      log "Alarm #{alarm_code_id} is now Inactive on component #{component_id}"
+    end
+  end
+
+  # Validate that an alarm can be acknowledged.
+  #
+  # The test expects that the TLC is programmed so that an detector logic fault
+  # alarm A0302 is raised and can be acknowledged when a specific input is activated.
+  # The alarm code and input nr is read from the test configuration.
+  #
+  # 1. Given the site is connected
+  # 2. When we trigger an alarm
+  # 3. Then we should receive an unacknowledged alarm issue
+  # 4. When we acknowledge the alarm
+  # 5. Then we should receive an acknowledged alarm issue
+
+  it 'can acknowledge A0302' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      alarm_code_id = 'A0302' # what alarm to expect
+      timeout = RSMP::Validator.get_config('timeouts', 'alarm')
+
+      log "Activating alarm #{alarm_code_id}"
+      with_alarm_activated(site_proxy, alarm_code_id) do |alarm, component_id| # raise alarm, by activating input
+        log "Alarm #{alarm_code_id} is now active on component #{component_id}"
+
+        # verify timestamp
+        alarm_time = Time.parse(alarm.attributes['aTs'])
+        expect(alarm_time).to be_within(1.minute).of(Time.now.utc)
+
+        # verify that the alarm is not acknowledged when initially raised
+        ack_message = "Alarm should not be acknowledged when raised, got: #{alarm.attributes['ack']}"
+        assert(alarm.attributes['ack'].match?(/notAcknowledged/i), ack_message)
+        log "Verified alarm #{alarm_code_id} is correctly not acknowledged when raised"
+
+        # test acknowledge and confirm
+        log "Acknowledge alarm #{alarm_code_id}"
+
+        collect_task = Async::Task.current.async do
+          RSMP::AlarmCollector.new(site_proxy,
+                                   num: 1,
+                                   matcher: {
+                                     'aCId' => alarm_code_id,
+                                     'aSp' => /Acknowledge/i,
+                                     'ack' => /Acknowledged/i,
+                                     'aS' => /Active/i
+                                   },
+                                   timeout: timeout).collect!
+        end
+
+        site_proxy.send_message RSMP::AlarmAcknowledge.new(
+          'cId' => component_id,
+          'aTs' => site_proxy.clock.to_s,
+          'aCId' => alarm_code_id
+        )
+        messages = collect_task.wait
+        expect(messages).to be_a(Array)
+        expect(messages.first).to be_a(RSMP::Alarm)
+      end
+    end
+  end
+
+  # Validate that alarms can be suspended. We're using A0302 in this test.
+  #
+  # 1. Given the site is connected
+  # 2. And the alarm is resumed
+  # 3. When we suspend the alarm
+  # 4. Then we should received an alarm suspended messsage
+  # 5. When we resume the alarm
+  # 6. Then we should receive an alarm resumed message
+
+  it 'can suspende and resume A0302' do
+    with_site(:connected) do |site_proxy|
+      alarm_code_id = 'A0302'
+      _, 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
+
+      begin
+        # suspend alarm
+        _, response = site_proxy.suspend_alarm Async::Task.current, c_id: component_id, a_c_id: alarm_code_id,
+                                                                    collect: true
+        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
+        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
+      end
+    end
+  end
+end

data/test/site/tlc/clock_spec.rb

@@ -0,0 +1,252 @@
+describe 'Site::Tlc::Clock' do
+  include RSMP::Validator::Helpers::Clock
+  include RSMP::Validator::Helpers::Alarms
+
+  # Tests related to the clock.
+  # When you set the clock, the adjusted time should be used
+  # everywhere you get back a timestamp.
+  # Note that watchdog messages can be used to synchronize the clock,
+  # which can interfere with our tests. So we disable sending watchdogs
+  # during tests.
+
+  let(:clock) { Time.new(2020, 9, 29, 17, 29, 51, '+00:00') }
+
+  # Verify status 0096 current date and time
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  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!
+    end
+  end
+
+  # Verify that the controller responds to M0104
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send command
+  # 3. Expect status response before timeout
+  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)
+    end
+  end
+
+  # Verify status S0096 clock after changing clock
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send control command to set_clock
+  # 3. Request status S0096
+  # 4. Compare set_clock and status timestamp
+  # 5. Expect the difference to be within max_diff
+  it 'is used for S0096 status response' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
+        command_timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+        with_clock_set site_proxy, clock, within: command_timeout do
+          status_list = { S0096: %i[
+            year
+            month
+            day
+            hour
+            minute
+            second
+          ] }
+          timeout = RSMP::Validator.get_config('timeouts', 'status_update')
+          collector = site_proxy.request_status_and_collect(
+            status_list,
+            within: timeout
+          )
+          collector.ok!
+          status = status_list.keys.first.to_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'],
+            'UTC'
+          )
+
+          max_diff = RSMP::Validator.get_config('timeouts', 'command_response') +
+                     RSMP::Validator.get_config('timeouts', 'status_response')
+
+          diff = received - clock
+          diff = diff.round
+          assert(diff.abs <= max_diff,
+                 "Clock reported by S0096 is off by #{diff}s, should be within #{max_diff}s")
+        end
+      end
+    end
+  end
+
+  # Verify status response timestamp after changing clock
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send control command to set_clock
+  # 3. Request status S0096
+  # 4. Compare set_clock and response timestamp
+  # 5. Expect the difference to be within max_diff
+  it 'is used for S0096 response timestamp' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
+        with_clock_set site_proxy, clock, within: RSMP::Validator.get_config('timeouts', 'command_response') do
+          status_list = { S0096: %i[
+            year
+            month
+            day
+            hour
+            minute
+            second
+          ] }
+
+          timeout = RSMP::Validator.get_config('timeouts', 'status_response')
+          collector = site_proxy.request_status_and_collect(status_list,
+                                                            within: timeout)
+          collector.ok!
+
+          max_diff = RSMP::Validator.get_config('timeouts', 'command_response') + timeout
+          diff = Time.parse(collector.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")
+        end
+      end
+    end
+  end
+
+  # Verify aggregated status response timestamp after changing clock
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send control command to set clock
+  # 3. Wait for status = true
+  # 4. Request aggregated status
+  # 5. Compare set_clock and response timestamp
+  # 6. Expect the difference to be within max_diff
+  it 'is used for aggregated status timestamp' do
+    skip 'requires core >= 3.1.5' unless RSMP::Validator.core_matches?('>=3.1.5')
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
+        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)
+          max_diff = RSMP::Validator.get_config('timeouts', 'command_response') + timeout
+          diff = Time.parse(collector.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")
+        end
+      end
+    end
+  end
+
+  # Verify command response timestamp after changing clock
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send control command to set clock
+  # 3. Send command to set functional position
+  # 4. Compare set_clock and response timestamp
+  # 5. Expect the difference to be within max_diff
+  it 'is used for M0001 response timestamp' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      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]
+          max_diff = timeout * 2
+          diff = Time.parse(collector.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")
+        end
+      end
+    end
+  end
+
+  # Verify command response timestamp after changing clock
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send control command to set clock
+  # 3. Send command to set functional position
+  # 4. Compare set_clock and response timestamp
+  # 5. Expect the difference to be within max_diff
+  it 'is used for M0104 response timestamp' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      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]
+          max_diff = timeout
+          diff = Time.parse(collector.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")
+        end
+      end
+    end
+  end
+
+  # Verify timestamp of alarm after changing clock
+  # The test requires the device to be programmed so that
+  # a A0302 alarm can be raise by activating a specific input, as
+  # configuted in the test config.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send a command to change the clock
+  # 3. And we raise an alarm, by acticate an input
+  # 4. Then we should receive an alarm
+  # 5. And the alarm timestamp should be close to the time set the clock to
+
+  it 'is used for alarm timestamp' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
+        command_timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+        with_clock_set site_proxy, clock, within: command_timeout do # set clock
+          with_alarm_activated(site_proxy, 'A0302') do |alarm| # raise alarm, by activating input
+            alarm_time = Time.parse(alarm.attributes['aTs'])
+            max_diff = RSMP::Validator.get_config('timeouts', 'command_response') +
+                       RSMP::Validator.get_config('timeouts', 'status_response')
+            diff = alarm_time - clock
+            assert(diff.round.abs <= max_diff,
+                   "Timestamp of alarm is off by #{diff}s, should be within #{max_diff}s")
+          end
+        end
+      end
+    end
+  end
+
+  # Verify timestamp of watchdog after changing clock
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send control command to setset_clock
+  # 3. Wait for Watchdog
+  # 4. Compare set_clock and alarm response timestamp
+  # 5. Expect the difference to be within max_diff
+  it 'is used for watchdog timestamp' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
+        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.collect!
+          max_diff = RSMP::Validator.get_config('timeouts', 'command_response') +
+                     RSMP::Validator.get_config('timeouts', 'status_response')
+          diff = Time.parse(collector.messages.first.attributes['wTs']) - clock
+          diff = diff.round
+          assert(diff.abs <= max_diff,
+                 "Timestamp of watchdog is off by #{diff}s, should be within #{max_diff}s")
+        end
+      end
+    end
+  end
+end

data/test/site/tlc/detector_logics_spec.rb

@@ -0,0 +1,76 @@
+describe 'Site::Tlc::DetectorLogics' do
+  include RSMP::Validator::Helpers::Status
+  include RSMP::Validator::Helpers::Input
+
+  # Verify status S0016 number of detector logics
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  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!
+    end
+  end
+
+  # Verify status S0002 detector logic status
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  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!
+    end
+  end
+
+  # Verify status S0021 manually set detector logic
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  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!
+    end
+  end
+
+  # 1. Verify connection
+  # 2. Send control command to switch detector_logic= true
+  # 3. Wait for status = true
+  it 'forcing is set with M0008' 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)
+        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)
+        wait_for_status(
+          site_proxy,
+          "detector logic #{component} to be False",
+          [{ 'sCI' => 'S0002', 'n' => 'detectorlogicstatus', 's' => /^.{#{indx}}0/ }]
+        )
+      end
+    end
+  end
+
+  # Verify status S0031 trigger level sensitivity for loop detector
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  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!
+    end
+  end
+end