[Test Teardown] Cleanup coverage extended to DUTs commissioned during the test (not by the test runner) (project-chip#72906)

* improve logging

* remove unused var

* clarify comments

* fix ci fail

* fix ci

Author: raul-marquez-csa

src/python_testing/matter_testing_infrastructure/matter/testing/basic_composition.py

@@ -180,6 +180,10 @@ def log_test_start():
             LOGGER.info("###########################################################")
 
         if self.test_from_file:
+            # File-mode runs have no DUT: skip the pre-test DUT-state capture used by
+            # teardown cleanup and the background wildcard subscription, both gated on
+            # requires_dut in setup_test.
+            self.requires_dut = False
             cache = JsonToMatterTlv(self.test_from_file)
             self.endpoints = cache.GetUpdatedAttributeCache()
             self.endpoints_tlv = cache.attributeTLVCache

src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py

@@ -527,13 +527,15 @@ class MatterBaseTest(base_test.BaseTestClass):
     Wildcard subscription (see setup_test), a SEPARATE concern from device classification:
 
     * Set class attribute requires_dut = False for tests that do not interact with a
-      real DUT (e.g. parser/conformance unit tests under test_testing/).  Such tests
-      will skip the background wildcard subscription so they don't try to subscribe to a
-      device that isn't there.  Default is True. This flag is independent of the
-      device-STATE markers (MatterTestCommissionedDevice / MatterTestUncommissionedDevice /
-      MatterTestCommissioner); do not derive one from the other. The sole exception is
-      CertificationUnitTestNoDevice, which sets requires_dut = False on the base since a
-      no-device test can never use the subscription.
+      DUT (e.g. parser/conformance unit tests under test_testing/).  Such tests
+      will skip the background wildcard subscription and the pre-test DUT-state capture,
+      so they don't attempt network operations against a device that isn't there.
+      Default is True. This flag is independent of the device-STATE markers
+      (MatterTestCommissionedDevice / MatterTestUncommissionedDevice / MatterTestCommissioner);
+      do not derive one from the other. The sole exception is CertificationUnitTestNoDevice,
+      which sets requires_dut = False on the base since a no-device test can never use
+      the subscription.
+
     * Set class attribute disable_wildcard_subscription = True to skip the background
       wildcard subscription and its ACL side effects — same effect as --no-wildcard-subscription.
     * When a wildcard subscription is active, read_single_attribute_check_success compares
@@ -567,9 +569,6 @@ def __init__(self, *args):
         # Pre-test snapshot of the DUT's fabric identities
         self._original_fabrics = None
         self._framework_cleanup_done = False
-        # Set to True by commission_devices() on success; gates the per-test ACL read in
-        # setup_test so unit tests (which never commission) incur zero network overhead.
-        self._dut_confirmed_available = False
         # Prevents double-execution when the override calls super().teardown_test()
         # and __init_subclass__ also calls it afterward.
         self._teardown_ran = False
@@ -1172,10 +1171,12 @@ async def _purge_scenes(self) -> None:
             LOGGER.info("[CLN] wildcard not available, skipping scene cleanup")
             return
 
+        found_any = False
         for endpoint_id in self.stored_global_wildcard.attributes:
             if not _has_cluster(wildcard=self.stored_global_wildcard, endpoint=endpoint_id,
                                 cluster=Clusters.ScenesManagement):  # type: ignore[arg-type]
                 continue
+            found_any = True
             if not _has_cluster(wildcard=self.stored_global_wildcard, endpoint=endpoint_id,
                                 cluster=Clusters.Groups):  # type: ignore[arg-type]
                 continue
@@ -1199,6 +1200,8 @@ async def _purge_scenes(self) -> None:
                 LOGGER.info("[CLN] scenes cleared on endpoint %d", endpoint_id)
             except Exception as e:  # DUT may be unreachable or the group may have been removed by the test
                 LOGGER.warning("[CLN] scene removal failed on endpoint %d: %s", endpoint_id, e)
+        if not found_any:
+            LOGGER.info("[CLN] ScenesManagement cluster not present on any endpoint, skipping scene cleanup")
 
     async def _purge_group_memberships(self) -> None:
         """Removes all group memberships from the DUT's group table.
@@ -1459,33 +1462,36 @@ def setup_test(self):
         self._framework_cleanup_done = False
         self.cleanup_config = TestCleanupConfig()
         self._validate_test_parameters()
-        # Capture the ACL before the test runs so _reset_acls_to_default can restore it
-        # in teardown_class. Skip when the DUT is not known to be available: unit tests
-        # never commission a device so _dut_confirmed_available stays False, and
-        # commissioning_method is None, eliminating any network overhead for them.
-        # For runner-commissioned tests commissioning_method is set; for in-test
-        # commissioning the flag is set by commission_devices() on success.
-        # is_commissioning is True for CommissionDeviceTest, where the DUT is not yet
-        # on the fabric, an operational read there would send CASE Sigma1 to an
-        # uncommissioned device, triggering unexpected DUT behaviour.
-        dut_expected = (
-            not self.is_commissioning
-            and (
-                self._dut_confirmed_available
-                or self.matter_test_config.commissioning_method is not None
-            )
-        )
+        # Capture the ACL so _reset_acls_to_default can restore it during framework cleanup.
+        # Captured when:
+        # - the DUT is commissioned (runner or in-test)
+        # Skipped when:
+        # - requires_dut is False (unit tests, file mode)
+        # - is_commissioning is True (DUT not on the fabric yet)
+        # - the probe fails (PASE-only connection, or DUT absent/unreachable)
+        dut_expected = not self.is_commissioning and self.requires_dut
         if dut_expected:
             try:
-                self._original_acl = self.event_loop.run_until_complete(
-                    self.read_single_attribute_check_success(
-                        cluster=Clusters.AccessControl,
-                        attribute=Clusters.AccessControl.Attributes.Acl,
-                        endpoint=0
-                    )
-                )
-            except Exception:
+                self.event_loop.run_until_complete(
+                    self.default_controller.GetConnectedDevice(
+                        nodeId=self.dut_node_id, allowPASE=False, timeoutMs=5000))
+            except Exception as e:
+                LOGGER.info("[CLN] No CASE session to the DUT (not commissioned, or unreachable), "
+                            "skipping pre-test ACL capture: %s", e)
                 self._original_acl = None
+            else:
+                try:
+                    self._original_acl = self.event_loop.run_until_complete(
+                        self.read_single_attribute_check_success(
+                            cluster=Clusters.AccessControl,
+                            attribute=Clusters.AccessControl.Attributes.Acl,
+                            endpoint=0
+                        )
+                    )
+                    LOGGER.info("[CLN] Pre-test ACL captured (%d entries)", len(self._original_acl))
+                except Exception as e:
+                    LOGGER.warning("[CLN] Pre-test ACL capture failed, teardown will skip ACL restore: %s", e)
+                    self._original_acl = None
 
             # Capture the pre-existing fabrics _remove_extra_fabrics uses this snapshot so that
             # only fabrics added during the test are removed
@@ -1505,7 +1511,7 @@ def setup_test(self):
 
         if self.runner_hook and not self.is_commissioning:
             # Start the background wildcard subscription only for tests that interact with a
-            # real DUT (requires_dut = True, the default) and unless the test has opted out
+            # DUT (requires_dut = True, the default) and unless the test has opted out
             # via --no-wildcard-subscription or disable_wildcard_subscription = True on
             # the test class (e.g. tests that directly manipulate the ACL or tests that count
             # the TH entries).
@@ -2287,10 +2293,7 @@ async def commission_devices(self) -> bool:
             thread_ba_port=self.matter_test_config.thread_ba_port,
         )
 
-        result = await commission_devices(dev_ctrl, dut_node_ids, setup_payloads, commissioning_info)
-        if result:
-            self._dut_confirmed_available = True
-        return result
+        return await commission_devices(dev_ctrl, dut_node_ids, setup_payloads, commissioning_info)
 
     async def commission_ntl_device(self, setup_payload: SetupPayload) -> bool:
         """Commission a single DUT devices over NTL.