fix: preserve lifo recency when scope upgrade replaces an entry

bdraco · bdraco · commit c31118fb565e · 2026-05-20T15:33:42.000-05:00
In _get_ip_addresses_from_cache_lifo, an in place replacement of an
existing address kept the upgraded entry at its original insertion index.
After the final reverse to produce LIFO order, an unrelated address that
arrived between the unscoped and the scoped variant ended up ahead of
the upgrade, breaking the recency guarantee. Pop the existing entry and
re append so the later observation wins both in value and in LIFO
position.
diff --git a/src/zeroconf/_services/info.py b/src/zeroconf/_services/info.py
@@ -496,8 +496,10 @@ def _get_ip_addresses_from_cache_lifo(
             if existing_idx == -1:
                 address_list.append(ip_addr)
                 continue
-            if _has_more_scope_info(ip_addr, address_list[existing_idx]):
-                address_list[existing_idx] = ip_addr
+            # Move the re-seen address to the end so the later observation
+            # wins both in value (scope) and in LIFO position after reverse.
+            existing = address_list.pop(existing_idx)
+            address_list.append(ip_addr if _has_more_scope_info(ip_addr, existing) else existing)
         address_list.reverse()  # Reverse to get LIFO order
         return address_list
 
diff --git a/tests/services/test_info.py b/tests/services/test_info.py
@@ -937,6 +937,76 @@ def test_has_more_scope_info_returns_false_for_ipv4():
     assert _has_more_scope_info(ip4, ip4) is False
 
 
+def test_scope_upgrade_preserves_lifo_recency_order():
+    """A scoped AAAA that upgrades an earlier entry becomes the most recent in LIFO order."""
+    type_ = "_http._tcp.local."
+    registration_name = f"reorder.{type_}"
+    zeroconf = r.Zeroconf(interfaces=["127.0.0.1"])
+    host = "reorder.local."
+    link_local = socket.inet_pton(socket.AF_INET6, "fe80::52e:c2f2:bc5f:e9c6")
+    ula = socket.inet_pton(socket.AF_INET6, "fdc8:d776:7cca:46ed::2")
+
+    zeroconf.cache.async_add_records(
+        [
+            r.DNSPointer(
+                type_,
+                const._TYPE_PTR,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                120,
+                registration_name,
+            ),
+            r.DNSService(
+                registration_name,
+                const._TYPE_SRV,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                120,
+                0,
+                0,
+                80,
+                host,
+            ),
+            r.DNSAddress(
+                host,
+                const._TYPE_AAAA,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                120,
+                link_local,
+                scope_id=None,
+            ),
+            r.DNSAddress(
+                host,
+                const._TYPE_AAAA,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                120,
+                ula,
+                scope_id=None,
+            ),
+            r.DNSAddress(
+                host,
+                const._TYPE_AAAA,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                120,
+                link_local,
+                scope_id=11,
+            ),
+        ]
+    )
+
+    info = ServiceInfo(type_, registration_name)
+    info.load_from_cache(zeroconf)
+    # The scoped link-local upgrade is the most recent observation, so it
+    # has to come first in LIFO order, ahead of the earlier unrelated ULA.
+    assert info.ip_addresses_by_version(r.IPVersion.V6Only) == [
+        ip_address("fe80::52e:c2f2:bc5f:e9c6%11"),
+        ip_address("fdc8:d776:7cca:46ed::2"),
+    ]
+    assert info.parsed_scoped_addresses() == [
+        "fe80::52e:c2f2:bc5f:e9c6%11",
+        "fdc8:d776:7cca:46ed::2",
+    ]
+    zeroconf.close()
+
+
 # This test uses asyncio because it needs to access the cache directly
 # which is not threadsafe
 @pytest.mark.asyncio
