fix(protocols): compose IPv6_Ext.id() from its direct concrete members (#2462)

- IPv6_Ext.id() returns the class names of its direct concrete
  subclasses (HOPOPT, IPv6_Route, IPv6_Frag, ESP, AH, IPv6_Opts, MH,
  HIP), so selecting 'IPv6_Ext' matches every extension header.
- HOPOPT, IPv6_Frag, IPv6_Opts, IPv6_Route, MH and HIP narrow id() to
  their own class name, as AH and ESP already do; their id() output is
  unchanged from main.
- Document id() on the family and member pages.
- Tests derive the member set from IPv6_Ext.__subclasses__() and check
  protochain selection on parsed HOPOPT, IPv6-Opts and IPv6-Frag packets.

Narrow pytest selection: 387 passed, 15 skipped; isort, pylint and mypy
add no findings on the touched files.

Author: JarryShaw

pcapkit/protocols/internet/ipv6_ext.py

@@ -380,24 +380,16 @@ def protochain(self) -> 'ProtoChain | NoReturn':
     ##########################################################################
 
     @classmethod
-    def id(cls) -> 'tuple[Literal["IPv6_Ext"]]':
+    def id(cls) -> 'tuple[Literal["HOPOPT"], Literal["IPv6_Route"], Literal["IPv6_Frag"], Literal["ESP"], Literal["AH"], Literal["IPv6_Opts"], Literal["MH"], Literal["HIP"]]':  # pylint: disable=line-too-long
         """Index ID of the protocol.
 
         Returns:
-            Index ID of the protocol -- just this class's own name, *not* a
-            family-wide list of every member's name as :meth:`IPsec.id
-            <pcapkit.protocols.internet.ipsec.IPsec.id>` returns for its own
-            family. Unlike ``IPsec``, this class is also the documented
-            *concrete fallback parser* described above:
-            :attr:`~pcapkit.const.ipv6.extension_header.ExtensionHeader.Shim6`
-            registers to it directly, and any :rfc:`6564`-conforming header
-            whose dedicated class is absent or raised falls back to it too.
-            Listing the sibling names would make such a fallback-parsed
-            packet falsely match e.g. ``'AH'`` or ``'HOPOPT'`` in its
-            protocol chain even though it is neither.
+            Index ID of every direct concrete subclass, each of which narrows
+            its own :meth:`id` to itself. A header parsed by this class as the
+            generic fallback therefore matches every one of these names.
 
         """
-        return ('IPv6_Ext',)
+        return ('HOPOPT', 'IPv6_Route', 'IPv6_Frag', 'ESP', 'AH', 'IPv6_Opts', 'MH', 'HIP')
 
     def read(self, length: 'Optional[int]' = None, *,  # pylint: disable=arguments-differ
              extension: 'bool' = False, **kwargs: 'Any') -> '_PT':

tests/protocols/internet/test_ipv6_ext_unit.py

@@ -299,67 +299,43 @@ def test_alias_is_hyphenated_like_its_siblings(self) -> None:
         # so the hyphen matters, not just the dash-free text either side of it.
         self.assertEqual(inst.alias.lstrip('IPv6-').lower(), 'ext')
 
-    # -- id(): class-name dispatch tuples, not family-wide, not alias strings --
-
-    def test_id_pins_every_touched_class_to_its_own_class_name(self) -> None:
-        """Every class in this family uses its own Python class name in
-        ``id()``, never the (possibly hyphenated) ``alias`` string -- the
-        same convention as ``ARP``/``InARP``, ``C_Tag``/``S_Tag`` and
-        ``HTTPv1``/``HTTPv2`` elsewhere in this package. ``IPv6_Ext`` is
-        pinned to *only* its own name, not a family-wide tuple: see
-        ``test_fallback_parsed_packet_does_not_match_a_sibling_name`` below
-        for why a family-wide tuple would be a real bug here.
-        """
-        from pcapkit.protocols.internet.hip import HIP
-        from pcapkit.protocols.internet.hopopt import HOPOPT
+    # -- id(): the family composes its members, each member narrows -------
+
+    def test_id_composes_every_direct_concrete_subclass(self) -> None:
+        """Derived from the live hierarchy, so a new member cannot drift."""
+        import inspect
+
+        import pcapkit.protocols  # noqa: F401  # pylint: disable=unused-import
         from pcapkit.protocols.internet.ipv6_ext import IPv6_Ext
-        from pcapkit.protocols.internet.ipv6_frag import IPv6_Frag
-        from pcapkit.protocols.internet.ipv6_opts import IPv6_Opts
-        from pcapkit.protocols.internet.ipv6_route import IPv6_Route
-        from pcapkit.protocols.internet.mh import MH
 
-        expected = {
-            IPv6_Ext: ('IPv6_Ext',),
-            HOPOPT: ('HOPOPT',),
-            IPv6_Frag: ('IPv6_Frag',),
-            IPv6_Opts: ('IPv6_Opts',),
-            IPv6_Route: ('IPv6_Route',),
-            MH: ('MH',),
-            HIP: ('HIP',),
-        }
-        for klass, want in expected.items():
+        members = [klass for klass in IPv6_Ext.__subclasses__() if not inspect.isabstract(klass)]
+        self.assertCountEqual(IPv6_Ext.id(), [klass.__name__ for klass in members])
+        for klass in members:
             with self.subTest(cls=klass.__qualname__):
-                self.assertEqual(klass.id(), want)
-
-    def test_fallback_parsed_packet_does_not_match_a_sibling_name(self) -> None:
-        """The regression this fix closes. Before it, ``IPv6_Ext.id()``
-        listed every family member's alias -- including ``'AH'``,
-        ``'HOPOPT'`` and ``'MH'`` -- so a Shim6-carrying packet (or any
-        packet whose extension header fell back to this generic parser,
-        since it is the documented concrete fallback for GitHub issue #917)
-        would falsely match e.g. ``'AH' in protochain`` even though it
-        carries none of those protocols. ``ProtoChain.__contains__`` calls
-        ``proto.id()`` on every chain entry
-        (``pcapkit/corekit/protochain.py``), so this was a real false
-        positive reachable through a public API, not merely an internal
-        detail.
-
-        Fails on the pre-fix ``IPv6_Ext.id()`` (returns the 7-member
-        family tuple): ``'AH' in ipv6.protochain`` is ``True`` there.
-        """
+                self.assertEqual(klass.id(), (klass.__name__,))
+                self.assertIn(klass.__name__.upper(), IPv6_Ext.expand_comp('IPv6_Ext'))
+
+    def test_selector_matches_by_member_and_by_family(self) -> None:
+        """A member name matches only that member; the family name matches all."""
         from pcapkit.const.ipv6.extension_header import ExtensionHeader
         from pcapkit.const.reg.transtype import TransType
         from pcapkit.protocols.internet.ipv6 import IPv6
 
-        shim6_ext = bytes([int(TransType.UDP), 1]) + b'\x00' * 14  # 16 octets, generic rule
-        udp_payload = _udp_bytes(b'shim6-ok')
-        raw = _ipv6_bytes(int(ExtensionHeader.Shim6), shim6_ext + udp_payload)
-        ipv6 = IPv6(io.BytesIO(raw), len(raw))
-
-        self.assertIn('IPv6_Ext', ipv6.protochain)
-        for sibling in ('AH', 'ESP', 'HOPOPT', 'MH'):
-            with self.subTest(sibling=sibling):
-                self.assertNotIn(sibling, ipv6.protochain)
+        generic = bytes([int(TransType.UDP), 0]) + b'\x00' * 6  # (0+1)*8 == 8 octets
+        headers = {
+            'HOPOPT': (ExtensionHeader.HOPOPT, generic),
+            'IPv6_Opts': (ExtensionHeader.IPv6_Opts, generic),
+            'IPv6_Frag': (ExtensionHeader.IPv6_Frag, bytes([int(TransType.UDP)]) + b'\x00' * 7),
+        }
+        for name, (code, ext) in headers.items():
+            raw = _ipv6_bytes(int(code), ext + _udp_bytes(b'ok'))
+            ipv6 = IPv6(io.BytesIO(raw), len(raw))
+            with self.subTest(header=name):
+                self.assertIn(name, ipv6.protochain)
+                self.assertIn('IPv6_Ext', ipv6.protochain)
+                for other in headers:
+                    if other != name:
+                        self.assertNotIn(other, ipv6.protochain)
 
     # -- the version gate: this class only ever activates for IPv6 ----------