tests: split TestUDP/TCPConnections sequential scenarios into separate tests

test_basic_udp_message_reception and test_basic_tcp_message_reception
each ran three signing scenarios sequentially in a single pytest
method, so xdist had to schedule them on a single worker and wall-clock
was the sum of all three (≈ test_duration + 10s child-idle wait per
scenario for the UDP case = ~46s).

Split each into three top-level tests (test_unsigned_engineer,
test_bad_signing_key, test_good_signing_key) so -j 0 distributes
them. Connection phase wall-clock with -j 0 drops from ~55s to ~25s.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: tridge

tests/test_connections.py

@@ -300,188 +300,74 @@ def run_test_scenario(self, test_server, user_conn_type, engineer_conn_type,
 
 
 class TestUDPConnections(BaseConnectionTest):
-    """Test suite for UDP connection functionality using PyMAVLink 
-    with authentication."""
+    """UDP/UDP scenarios. One method per signing case so xdist can run
+    them in parallel — each one pays the proxy's 10s conn1-idle wait,
+    so collapsing them into a single sequential method made wall-clock
+    time roughly the sum."""
 
-    def test_basic_udp_message_reception(self, test_server):
-        """Test UDP message reception with different authentication scenarios."""
-
-        # Test scenario 1: Engineer without signed connection
-        print("\n=== TEST 1: Engineer without signed connection ===")
-        self._test_unsigned_engineer(test_server)
-
-        # Test scenario 2: Engineer with bad signing key
-        print("\n=== TEST 2: Engineer with bad signing key ===")
-        self._test_bad_signing_key(test_server)
-
-        # Test scenario 3: Engineer with correct signing key
-        print("\n=== TEST 3: Engineer with correct signing key ===")
-        self._test_good_signing_key(test_server)
-
-    def _test_unsigned_engineer(self, test_server):
-        """Test engineer connection without signing - should only get HEARTBEAT."""
+    def test_unsigned_engineer(self, test_server):
+        """Engineer without signing - should only get HEARTBEAT."""
         heartbeat_count, system_time_count = self.run_test_scenario(
             test_server, 'udp', 'udp', engineer_signing_key=None, test_duration=3
         )
-
         assert heartbeat_count > 0, \
             "Engineer should receive HEARTBEAT messages even without signing"
         assert system_time_count == 0, \
             "Engineer should NOT receive SYSTEM_TIME without proper signing"
-        print(f"SUCCESS: Unsigned engineer received {heartbeat_count} HEARTBEAT, "
-              f"{system_time_count} SYSTEM_TIME (expected)")
-
-        expected_messages = ["Need to use support signing key"]
-        found_messages = self.check_udpproxy_output(
-            test_server, expected_messages)
 
-        if "Need to use support signing key" in found_messages:
-            print("✅ CONFIRMED: UDPProxy logged 'Need to use support signing key'")
-        else:
-            print("⚠️  UDPProxy output doesn't contain expected signing message")
-
-    def _test_bad_signing_key(self, test_server):
-        """Test engineer connection with bad signing key."""
-        bad_passphrase = "wrong_auth"  # Different from TEST_PASSPHRASE
-        bad_key = passphrase_to_key(bad_passphrase)
-
-        heartbeat_count, system_time_count = self.run_test_scenario(
-            test_server, 'udp', 'udp', engineer_signing_key=bad_key, test_duration=6
+    def test_bad_signing_key(self, test_server):
+        """Engineer with the wrong passphrase - nothing through."""
+        bad_key = passphrase_to_key("wrong_auth")
+        self.run_test_scenario(
+            test_server, 'udp', 'udp', engineer_signing_key=bad_key, test_duration=4
         )
-
-        print(f"SUCCESS: Bad key engineer received {heartbeat_count} HEARTBEAT, "
-              f"{system_time_count} SYSTEM_TIME (sent 6 seconds of signed messages)")
-
         expected_messages = ["Bad support signing key"]
-        found_messages = self.check_udpproxy_output(
-            test_server, expected_messages)
-
-        if found_messages:
-            print(f"✅ FOUND bad signing messages: {found_messages}")
-        else:
-            print("⚠️  UDPProxy output doesn't contain expected bad key message")
+        self.check_udpproxy_output(test_server, expected_messages)
 
-    def _test_good_signing_key(self, test_server):
-        """Test engineer connection with correct signing key - should get both 
-        HEARTBEAT and SYSTEM_TIME."""
+    def test_good_signing_key(self, test_server):
+        """Engineer with the correct key - should get HEARTBEAT and SYSTEM_TIME."""
         correct_key = passphrase_to_key(TEST_PASSPHRASE)
-
         heartbeat_count, system_time_count = self.run_test_scenario(
             test_server, 'udp', 'udp', engineer_signing_key=correct_key, test_duration=4
         )
-
         assert heartbeat_count > 0, "Engineer should receive HEARTBEAT messages"
         assert system_time_count > 0, \
             "Engineer should receive SYSTEM_TIME messages with correct signing"
-        print(f"SUCCESS: Correct key engineer received {heartbeat_count} HEARTBEAT, "
-              f"{system_time_count} SYSTEM_TIME")
-
-        expected_messages = ["Got good signature"]
-        found_messages = self.check_udpproxy_output(
-            test_server, expected_messages)
-
-        if found_messages:
-            print(f"✅ FOUND authentication messages: {found_messages}")
-        else:
-            print("⚠️  No authentication messages found in UDPProxy output")
 
 
 class TestTCPConnections(BaseConnectionTest):
-    """Test suite for TCP connection functionality using PyMAVLink 
-    with authentication."""
-
-    def test_basic_tcp_message_reception(self, test_server):
-        """Test TCP message reception with different authentication scenarios."""
-
-        # Test scenario 1: Engineer without signed connection
-        print("\n=== TCP TEST 1: Engineer without signed connection ===")
-        self._test_unsigned_engineer_tcp(test_server)
+    """TCP/TCP scenarios. Same parallel-friendly split as TestUDPConnections."""
 
-        # Test scenario 2: Engineer with bad signing key
-        print("\n=== TCP TEST 2: Engineer with bad signing key ===")
-        self._test_bad_signing_key_tcp(test_server)
-
-        # Test scenario 3: Engineer with correct signing key
-        print("\n=== TCP TEST 3: Engineer with correct signing key ===")
-        self._test_good_signing_key_tcp(test_server)
-
-    def _test_unsigned_engineer_tcp(self, test_server):
-        """Test engineer TCP connection without signing - should only get HEARTBEAT."""
+    def test_unsigned_engineer(self, test_server):
+        """Engineer TCP without signing - should only get HEARTBEAT."""
         heartbeat_count, system_time_count = self.run_test_scenario(
             test_server, 'tcp', 'tcp', engineer_signing_key=None,
             test_duration=3
         )
-
         assert heartbeat_count > 0, \
             "TCP Engineer should receive HEARTBEAT messages even without signing"
         assert system_time_count == 0, \
             "TCP Engineer should NOT receive SYSTEM_TIME without proper signing"
-        print(f"SUCCESS: TCP Unsigned engineer received {heartbeat_count} "
-              f"HEARTBEAT, {system_time_count} SYSTEM_TIME (expected)")
-
-        expected_messages = ["Need to use support signing key"]
-        found_messages = self.check_udpproxy_output(
-            test_server, expected_messages)
-
-        if "Need to use support signing key" in found_messages:
-            print("✅ CONFIRMED: UDPProxy logged 'Need to use support signing key' "
-                  "for TCP")
-        else:
-            print("⚠️  UDPProxy output doesn't contain expected signing message "
-                  "for TCP")
 
-    def _test_bad_signing_key_tcp(self, test_server):
-        """Test engineer TCP connection with bad signing key."""
-        bad_passphrase = "wrong_auth"  # Different from TEST_PASSPHRASE
-        bad_key = passphrase_to_key(bad_passphrase)
-
-        heartbeat_count, system_time_count = self.run_test_scenario(
+    def test_bad_signing_key(self, test_server):
+        """Engineer TCP with wrong passphrase - nothing through."""
+        bad_key = passphrase_to_key("wrong_auth")
+        self.run_test_scenario(
             test_server, 'tcp', 'tcp', engineer_signing_key=bad_key,
-            test_duration=8
+            test_duration=4
         )
 
-        print(f"SUCCESS: TCP Bad key engineer received {heartbeat_count} "
-              f"HEARTBEAT, {system_time_count} SYSTEM_TIME "
-              f"(sent 8 seconds of signed messages)")
-
-        expected_messages = ["Bad support signing key",
-                             "Need to use support signing key"]
-        found_messages = self.check_udpproxy_output(
-            test_server, expected_messages)
-
-        if found_messages:
-            print(f"✅ FOUND TCP bad signing messages: {found_messages}")
-        else:
-            print("⚠️  UDPProxy output doesn't contain expected bad key message "
-                  "for TCP")
-
-    def _test_good_signing_key_tcp(self, test_server):
-        """Test engineer TCP connection with correct signing key - should get 
-        both HEARTBEAT and SYSTEM_TIME."""
+    def test_good_signing_key(self, test_server):
+        """Engineer TCP with correct key - HEARTBEAT and SYSTEM_TIME flow."""
         correct_key = passphrase_to_key(TEST_PASSPHRASE)
-
         heartbeat_count, system_time_count = self.run_test_scenario(
             test_server, 'tcp', 'tcp', engineer_signing_key=correct_key,
             test_duration=4
         )
-
         assert heartbeat_count > 0, "TCP Engineer should receive HEARTBEAT messages"
-
         assert system_time_count > 0, \
             "TCP Engineer should receive SYSTEM_TIME messages with correct signing"
 
-        print(f"SUCCESS: TCP Correct key engineer received {heartbeat_count} "
-              f"HEARTBEAT, {system_time_count} SYSTEM_TIME")
-
-        expected_messages = ["Got good signature"]
-        found_messages = self.check_udpproxy_output(
-            test_server, expected_messages)
-
-        if found_messages:
-            print(f"✅ FOUND TCP authentication messages: {found_messages}")
-        else:
-            print("⚠️  No TCP authentication messages found in UDPProxy output")
-
 
 class TestMixedConnections(BaseConnectionTest):
     """Test suite for mixed UDP/TCP connection scenarios."""