Extend manifest v1 style handshake tests

tests/neo4j/test_summary.py

@@ -119,7 +119,7 @@ def test_protocol_version_information(self):
         max_server_protocol_version = get_server_info().max_protocol_version
         common_protocol_versions = [
             f.value.split(":")[-1] for f in self._driver_features
-            if (re.match(r"BOLT_\d+_\d+", f.name)
+            if (re.match(r"^BOLT_\d+_\d+$", f.name)
                 and f.value.split(":")[-1] <= max_server_protocol_version)
         ]
         if not common_protocol_versions:

tests/shared.py

@@ -221,6 +221,32 @@ def script_path(self, *path):
         base_path = os.path.dirname(inspect.getfile(self.__class__))
         return os.path.join(base_path, "scripts", *path)
 
+    def get_newest_bolt_supported_by_driver(
+        self,
+        skip=0,
+        min_version=(0, 0),
+        max_version=(0xFF, 0xFF),
+    ):
+        # skip: number of newest versions to skip (return n-th newest)
+        # min_version: minimum bolt version to consider
+        # max_version: maximum bolt version to consider
+        all_bolt_versions = [
+            (f, tuple(map(int, f.value.split(":")[-1].split("."))))
+            for f in protocol.Feature
+            if re.match(r"^BOLT_\d+_\d+$", f.name)
+        ]
+        filtered_bolt_versions = [
+            (f, v) for f, v in all_bolt_versions
+            if max_version >= v >= min_version
+        ]
+        filtered_bolt_versions.sort(key=lambda x: x[1], reverse=True)
+        for feature, version in filtered_bolt_versions:
+            if self.driver_supports_features(feature):
+                if skip <= 0:
+                    return version
+                skip -= 1
+        self.skipTest("No appropriate bolt version supported by driver")
+
     @contextmanager
     def subTest(self, **params):  # noqa: N802
         assert "msg" not in params

tests/stub/transport/scripts/test_parameterized_handshake_manifest.script

@@ -1,4 +1,4 @@
-!: BOLT 5.7
+!: BOLT #BOLT_VERSION#
 !: HANDSHAKE #HANDSHAKE#
 !: HANDSHAKE_RESPONSE #HANDSHAKE_RESPONSE#
 

tests/stub/transport/test_handshakes.py

@@ -40,12 +40,13 @@ def _get_session(self, server):
         finally:
             driver.close()
 
-    def _run(self, handshake, handshake_response):
+    def _run(self, handshake, handshake_response, bolt_version="5.7"):
         script_path = self.script_path(
             "test_parameterized_handshake_manifest.script"
         )
         vars_ = {
-            "#SERVER_AGENT#": "Neo4j/5.26.0"
+            "#SERVER_AGENT#": "Neo4j/5.26.0",
+            "#BOLT_VERSION#": bolt_version,
         }
         if handshake is not None:
             vars_["#HANDSHAKE#"] = handshake
@@ -83,10 +84,46 @@ def test_handshake_manifest_server_responses(self):
                 "00 00 01 FF 02 00 07 07 F2 00 07 07 05 00",
                 "00 00 07 05 00",
             ),
-
         ]:
             with self.subTest(
                 server_response=server_response,
                 expected_response=expected_response
             ):
                 self._run(server_response, expected_response)
+
+    @driver_feature(types.Feature.BOLT_HANDSHAKE_MANIFEST_V1)
+    def test_handshake_manifest_range_response_newer_server(self):
+        used_version = self.get_newest_bolt_supported_by_driver(
+            min_version=(5, 0), max_version=(5, 0xFF)
+        )
+        if used_version == (5, 0xFF):
+            raise ValueError(
+                "Test is moot if driver supports exact max version"
+            )
+        server_response, expected_response = (
+            "00 00 01 FF 02 00 00 04 04 00 FF FF 05 00",
+            f"00 00 {used_version[1]:02X} {used_version[0]:02X} 00",
+        )
+        self._run(
+            server_response,
+            expected_response,
+            bolt_version=".".join(map(str, used_version)),
+        )
+
+    @driver_feature(types.Feature.BOLT_HANDSHAKE_MANIFEST_V1)
+    def test_handshake_manifest_range_response_older_server(self):
+        used_version = self.get_newest_bolt_supported_by_driver(
+            skip=1, min_version=(5, 0), max_version=(5, 0xFF)
+        )
+        minor_major_hex = f"{used_version[1]:02X} {used_version[0]:02X}"
+        used_version_range_hex = f"00 {used_version[1]:02X} {minor_major_hex}"
+        used_version_hex = f"00 00 {minor_major_hex}"
+        server_response, expected_response = (
+            f"00 00 01 FF 02 00 00 04 04 {used_version_range_hex} 00",
+            f"{used_version_hex} 00",
+        )
+        self._run(
+            server_response,
+            expected_response,
+            bolt_version=".".join(map(str, used_version)),
+        )