IDM-14.1: Add closures sem tags test (project-chip#41382)

* IDM-14.1: Add closures test

* bot

* Add to test

* linter

* oh bot...I fell for your tricks and you deceived me

* Add test step to verify semantic tags on Closure device types

* restyle

* Fixed syntax error introduced by mistake and added helper function to check tags on endpoints

* Applied suggestion to improve get_namespace_id

* Apply suggestion from @AliTalebVelux

Co-authored-by: Ali Taleb <[email protected]>

* Apply suggestion from @gemini-code-assist[bot]

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* Apply suggestion from @gemini-code-assist[bot]

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* Added use of max_num_tags_allowed_namespace and named arguments for check_tags_on_endpoint

* Added named arguments for the missed check_tags_on_endpoint call

---------

Co-authored-by: cecille <[email protected]>
Co-authored-by: Ali Taleb <[email protected]>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: 4 people

src/python_testing/TC_DeviceConformance.py

@@ -87,15 +87,25 @@ def steps_TC_IDM_14_1(self):
                                 * Time Synchronization
                                 * TLS Certificate Management
                                 * TLS Client Management
-                         """, "No root-node-restricted clusters appear on non-root endpoints")]
+                         """, "No root-node-restricted clusters appear on non-root endpoints"),
+                TestStep(2, "Ensure the complex device type composition and conformance rules related to closure device types are met",
+                         "Closure cluster device type rules are met"),
+                TestStep(3, "Ensure the rules related to semantic tags for the closure device types are met",
+                         "Closure semantic tags rules are met")
+                ]
 
     def test_TC_IDM_14_1(self):
         self.step(0)  # wildcard read - done in setup
         self.step(1)
         problems = self.check_root_node_restricted_clusters()
+        self.step(2)
+        problems.extend(self.check_closure_restricted_clusters())
+        self.step(3)
+        problems.extend(self.check_closure_restricted_sem_tags())
+
         if problems:
             self.problems.extend(problems)
-            self.fail_current_test("One or more root-node-restricted clusters appear on non-root-node endpoints")
+            self.fail_current_test("One or more device conformance violations were found")
 
     def steps_TC_DESC_2_3(self):
         return [TestStep(0, "TH performs a wildcard read of all attributes on all endpoints on the device"),

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

@@ -118,9 +118,13 @@ def __str__(self):
 class DeviceTypePathLocation:
     device_type_id: int
     cluster_id: Optional[int] = None
+    endpoint_id: Optional[int] = None
 
     def __str__(self):
-        msg = f'\n       DeviceType: 0x{self.device_type_id:04X}'
+        msg = ""
+        if self.endpoint_id is not None:
+            msg += f'\n       Endpoint ID: {self.endpoint_id}'
+        msg += f'\n       DeviceType: 0x{self.device_type_id:04X}'
         if self.cluster_id:
             msg += f'\n       ClusterID: 0x{self.cluster_id:04X}'
         return msg

src/python_testing/test_testing/DeviceConformanceTests.py

@@ -16,7 +16,7 @@
 #
 
 
-from typing import Callable
+from typing import Callable, Optional
 
 import matter.clusters as Clusters
 from matter.testing.basic_composition import BasicCompositionTests
@@ -27,7 +27,8 @@
                                                  device_type_id_type, is_valid_device_type_id)
 from matter.testing.problem_notices import (AttributePathLocation, ClusterPathLocation, CommandPathLocation, DeviceTypePathLocation,
                                             ProblemNotice, ProblemSeverity)
-from matter.testing.spec_parsing import CommandType, XmlDeviceType, XmlDeviceTypeClusterRequirements
+from matter.testing.spec_parsing import (CommandType, PrebuiltDataModelDirectory, XmlDeviceType, XmlDeviceTypeClusterRequirements,
+                                         build_xml_device_types, build_xml_namespaces)
 from matter.tlv import uint
 
 
@@ -76,8 +77,10 @@ async def setup_class_helper(self):
         await super().setup_class_helper()
         self.build_spec_xmls()
 
-    def _get_device_type_id(self, device_type_name: str) -> int:
-        id = [id for id, dt in self.xml_device_types.items() if dt.name.lower() == device_type_name.lower()]
+    def _get_device_type_id(self, device_type_name: str, xml_device_types: Optional[dict[uint, XmlDeviceType]] = None) -> int:
+        if xml_device_types is None:
+            xml_device_types = self.xml_device_types
+        id = [id for id, dt in xml_device_types.items() if dt.name.lower() == device_type_name.lower()]
         if len(id) != 1:
             raise KeyError(f"Unable to find {device_type_name} device type")
         return id[0]
@@ -494,3 +497,82 @@ def check_root_node_restricted_clusters(self) -> list[ProblemNotice]:
                     problems.append(ProblemNotice("TC-IDM-14.1", location=ClusterPathLocation(endpoint_id=endpoint_id, cluster_id=cluster.id),
                                                   severity=ProblemSeverity.ERROR, problem=f"Root-node-restricted cluster {cluster} appears on non-root-node endpoint"))
         return problems
+
+    def check_closure_restricted_clusters(self) -> list[ProblemNotice]:
+        # This is a test that is SPECIFIC to the 1.5 spec, and thus we need the 1.5 spec information specifically
+        # to assess the revisions.
+        one_five_device_types, _ = build_xml_device_types(PrebuiltDataModelDirectory.k1_5)
+        # TODO: change this once https://github.com/project-chip/matter-test-scripts/issues/689 is implemented
+
+        window_covering_id = self._get_device_type_id('Window Covering', one_five_device_types)
+        closure_id = self._get_device_type_id('Closure', one_five_device_types)
+        closure_panel_id = self._get_device_type_id('Closure Panel', one_five_device_types)
+        restricted_device_type_ids = [window_covering_id, closure_id, closure_panel_id]
+
+        problems = []
+        for endpoint_id, endpoint in self.endpoints.items():
+            device_types = endpoint[Clusters.Descriptor][Clusters.Descriptor.Attributes.DeviceTypeList]
+            have_closure = Clusters.ClosureControl in endpoint.keys() or Clusters.ClosureDimension in endpoint.keys()
+            have_window_covering = Clusters.WindowCovering in endpoint.keys()
+
+            if have_closure and have_window_covering:
+                for dt in device_types:
+                    device_type_id = dt.deviceType
+                    if device_type_id in restricted_device_type_ids and dt.revision <= one_five_device_types[device_type_id].revision:
+                        problems.append(ProblemNotice("TC-IDM-14.1", location=DeviceTypePathLocation(endpoint_id=endpoint_id, device_type_id=device_type_id), severity=ProblemSeverity.ERROR,
+                                                      problem=f"Endpoint with device type {one_five_device_types[device_type_id].name} has both window covering and closure clusters"))
+        return problems
+
+    def check_closure_restricted_sem_tags(self) -> list[ProblemNotice]:
+        # This is a test that is SPECIFIC to the 1.5 spec, and thus we need the 1.5 spec information specifically
+        # to assess the revisions.
+        one_five_device_types, _ = build_xml_device_types(PrebuiltDataModelDirectory.k1_5)
+        one_five_namespaces, _ = build_xml_namespaces(PrebuiltDataModelDirectory.k1_5)
+        # TODO: change this once https://github.com/project-chip/matter-test-scripts/issues/689 is implemented
+
+        def get_namespace_id(name: str) -> uint:
+            ids = [id for id, xml in one_five_namespaces.items() if xml.name.lower() == name.lower()]
+            if len(ids) != 1:
+                raise ValueError(f"Unable to find unique namespace for '{name}'")
+            return ids[0]
+
+        closure_id = self._get_device_type_id('Closure', one_five_device_types)
+        closure_panel_id = self._get_device_type_id('Closure Panel', one_five_device_types)
+        closure_namespace_id = get_namespace_id('Closure')
+        closure_panel_namespace_id = get_namespace_id('Closure Panel')
+
+        def check_tags_on_endpoint(device_type_id: int, allowed_namespace: int, max_num_tags_allowed_namespace: int, disallowed_namespace: int):
+            tag_list = endpoint[Clusters.Descriptor][Clusters.Descriptor.Attributes.TagList]
+            allowed_tag_count = 0
+
+            for tag in tag_list:
+                if tag.namespaceID == disallowed_namespace:
+                    problems.append(ProblemNotice("TC-IDM-14.1", location=DeviceTypePathLocation(endpoint_id=endpoint_id, device_type_id=device_type_id), severity=ProblemSeverity.ERROR,
+                                                  problem=f"Endpoint with device type {one_five_device_types[device_type_id].name} has semantic tag {tag.tag} from namespace {one_five_namespaces[disallowed_namespace].name}"))
+                elif tag.namespaceID == allowed_namespace:
+                    allowed_tag_count += 1
+
+            if allowed_tag_count == 0:
+                problems.append(ProblemNotice("TC-IDM-14.1", location=DeviceTypePathLocation(endpoint_id=endpoint_id, device_type_id=device_type_id), severity=ProblemSeverity.ERROR,
+                                              problem=f"Endpoint with device type {one_five_device_types[device_type_id].name} is missing a {one_five_namespaces[allowed_namespace].name} namespace tag"))
+            elif allowed_tag_count > max_num_tags_allowed_namespace:
+                problems.append(ProblemNotice("TC-IDM-14.1", location=DeviceTypePathLocation(endpoint_id=endpoint_id, device_type_id=device_type_id), severity=ProblemSeverity.ERROR,
+                                              problem=f"Endpoint with device type {one_five_device_types[device_type_id].name} has multiple {one_five_namespaces[allowed_namespace].name} namespace tags"))
+
+        problems = []
+        for endpoint_id, endpoint in self.endpoints.items():
+            # If a Cloure or Closure Panel does not implement TagList, this is also invalid but is verified by another IDM test,
+            if Clusters.Descriptor.Attributes.TagList not in endpoint[Clusters.Descriptor]:
+                continue
+
+            device_types = endpoint[Clusters.Descriptor][Clusters.Descriptor.Attributes.DeviceTypeList]
+
+            for dt in device_types:
+                if dt.deviceType == closure_id:
+                    check_tags_on_endpoint(device_type_id=closure_id, allowed_namespace=closure_namespace_id,
+                                           max_num_tags_allowed_namespace=1, disallowed_namespace=closure_panel_namespace_id)
+                elif dt.deviceType == closure_panel_id:
+                    check_tags_on_endpoint(device_type_id=closure_panel_id, allowed_namespace=closure_panel_namespace_id,
+                                           max_num_tags_allowed_namespace=1, disallowed_namespace=closure_namespace_id)
+
+        return problems